From 97aaec464cb6dd7e491abd05b1619936f10eb12e Mon Sep 17 00:00:00 2001
From: Cookiebowser <lucas.doering@live.de>
Date: Thu, 11 May 2023 14:33:40 +0200
Subject: [PATCH] added MC-benchmarks for rust-embedded
---
.../Rust_embedded/CAN_BUS_tlc.rs | 1700 +++++++++++
.../Cruise_finite1_deterministic_MC.rs | 2011 ++++++++++++
.../Rust_embedded/LandingGear_R6.rs | 2717 +++++++++++++++++
.../Rust_embedded/Lift_MC_Large.rs | 354 +++
.../model_checking/Rust_embedded/Makefile | 32 +
.../Rust_embedded/Train1_Lukas_POR_v3.rs | 1386 +++++++++
...Train_1_beebook_deterministic_MC_POR_v2.rs | 1671 ++++++++++
.../model_checking/Rust_embedded/nota_v2.rs | 2112 +++++++++++++
8 files changed, 11983 insertions(+)
create mode 100644 benchmarks/model_checking/Rust_embedded/CAN_BUS_tlc.rs
create mode 100644 benchmarks/model_checking/Rust_embedded/Cruise_finite1_deterministic_MC.rs
create mode 100644 benchmarks/model_checking/Rust_embedded/LandingGear_R6.rs
create mode 100644 benchmarks/model_checking/Rust_embedded/Lift_MC_Large.rs
create mode 100644 benchmarks/model_checking/Rust_embedded/Makefile
create mode 100644 benchmarks/model_checking/Rust_embedded/Train1_Lukas_POR_v3.rs
create mode 100644 benchmarks/model_checking/Rust_embedded/Train_1_beebook_deterministic_MC_POR_v2.rs
create mode 100644 benchmarks/model_checking/Rust_embedded/nota_v2.rs
diff --git a/benchmarks/model_checking/Rust_embedded/CAN_BUS_tlc.rs b/benchmarks/model_checking/Rust_embedded/CAN_BUS_tlc.rs
new file mode 100644
index 000000000..72637d9c5
--- /dev/null
+++ b/benchmarks/model_checking/Rust_embedded/CAN_BUS_tlc.rs
@@ -0,0 +1,1700 @@
+#![ allow( dead_code, unused, non_snake_case, non_camel_case_types, unused_assignments ) ]
+//#![no_std] //std is enabled for the generated machine by default, since without it there is no println which makes unit-testing very difficult
+use btypes::{bset, brel};
+use btypes::bset::BSet;
+use btypes::bset::SetItem;
+use btypes::bset::PowSetItem;
+use btypes::bset::PowAble;
+use btypes::bset::NestedSet;
+use btypes::brelation::BRelation;
+use btypes::brelation::RelLeftItem;
+use btypes::brelation::RelPowAble;
+use btypes::bboolean::BBoolean;
+use btypes::bboolean::BBool;
+use btypes::bboolean::BOOL;
+use btypes::binteger::BInteger;
+use btypes::binteger::BInt;
+use btypes::binteger::set_BInteger;
+use btypes::btuple::BTuple;
+
+use std::env;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, mpsc, Mutex};
+use std::collections::{HashSet, LinkedList};
+use dashmap::DashSet;
+use threadpool::ThreadPool;
+use std::sync::mpsc::channel;
+use derivative::Derivative;
+use std::time::{Duration};
+
+
+
+#[derive(Clone, Copy)]
+pub enum MC_TYPE { BFS, DFS, MIXED }
+
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum T1state {
+ #[default]
+ T1_EN = 0,
+ T1_CALC = 1,
+ T1_SEND = 2,
+ T1_WAIT = 3
+}
+
+impl T1state {
+ pub fn equal(&self, other: &T1state) -> bool { *self == *other }
+ pub fn unequal(&self, other: &T1state) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::T1_EN,
+ 1 => Self::T1_CALC,
+ 2 => Self::T1_SEND,
+ 3 => Self::T1_WAIT,
+ _ => panic!("T1state index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<4> for T1state {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_T1state = BSet<T1state, 4>;
+//set_enum_declaration done
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum T2mode {
+ #[default]
+ T2MODE_SENSE = 0,
+ T2MODE_TRANSMIT = 1,
+ T2MODE_RELEASE = 2
+}
+
+impl T2mode {
+ pub fn equal(&self, other: &T2mode) -> bool { *self == *other }
+ pub fn unequal(&self, other: &T2mode) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::T2MODE_SENSE,
+ 1 => Self::T2MODE_TRANSMIT,
+ 2 => Self::T2MODE_RELEASE,
+ _ => panic!("T2mode index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<3> for T2mode {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_T2mode = BSet<T2mode, 3>;
+//set_enum_declaration done
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum T2state {
+ #[default]
+ T2_EN = 0,
+ T2_RCV = 1,
+ T2_PROC = 2,
+ T2_CALC = 3,
+ T2_SEND = 4,
+ T2_WAIT = 5,
+ T2_RELEASE = 6
+}
+
+impl T2state {
+ pub fn equal(&self, other: &T2state) -> bool { *self == *other }
+ pub fn unequal(&self, other: &T2state) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::T2_EN,
+ 1 => Self::T2_RCV,
+ 2 => Self::T2_PROC,
+ 3 => Self::T2_CALC,
+ 4 => Self::T2_SEND,
+ 5 => Self::T2_WAIT,
+ 6 => Self::T2_RELEASE,
+ _ => panic!("T2state index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<7> for T2state {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_T2state = BSet<T2state, 7>;
+//set_enum_declaration done
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum T3state {
+ #[default]
+ T3_READY = 0,
+ T3_WRITE = 1,
+ T3_RELEASE = 2,
+ T3_READ = 3,
+ T3_PROC = 4,
+ T3_WAIT = 5
+}
+
+impl T3state {
+ pub fn equal(&self, other: &T3state) -> bool { *self == *other }
+ pub fn unequal(&self, other: &T3state) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::T3_READY,
+ 1 => Self::T3_WRITE,
+ 2 => Self::T3_RELEASE,
+ 3 => Self::T3_READ,
+ 4 => Self::T3_PROC,
+ 5 => Self::T3_WAIT,
+ _ => panic!("T3state index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<6> for T3state {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_T3state = BSet<T3state, 6>;
+//set_enum_declaration done
+
+//relation_declaration
+type rel_BInteger_X_BInteger = BRelation<BInteger, { BInteger::VARIANTS }, BInteger, { BInteger::VARIANTS }, 0>;
+//relation_declaration done
+
+
+
+
+
+
+
+
+
+#[derive(Derivative)]
+#[derivative(Clone, Default, Debug, Hash, PartialEq, Eq)]
+pub struct CAN_BUS_tlc {
+ /*declarations*/BUSpriority: BInteger,
+ BUSvalue: BInteger,
+ BUSwrite: rel_BInteger_X_BInteger,
+ T1_state: T1state,
+ T1_timer: BInteger,
+ T1_writevalue: BInteger,
+ T2_mode: T2mode,
+ T2_readpriority: BInteger,
+ T2_readvalue: BInteger,
+ T2_state: T2state,
+ T2_timer: BInteger,
+ T2_writevalue: BInteger,
+ T2v: BInteger,
+ T3_enabled: BBoolean,
+ T3_evaluated: BBoolean,
+ T3_readpriority: BInteger,
+ T3_readvalue: BInteger,
+ T3_state: T3state,
+ /*constant_declarations*/NATSET: set_BInteger,
+ /*sets*//*set_declaration*/_T1state: set_T1state,
+ /*set_declaration*/_T2mode: set_T2mode,
+ /*set_declaration*/_T2state: set_T2state,
+ /*set_declaration*/_T3state: set_T3state,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_T1Evaluate: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_T1Calculate: Option<HashSet<BInteger>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_T1SendResult: Option<HashSet<(BInteger, BInteger)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_T1Wait: Option<HashSet<BInteger>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_T2Evaluate: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_T2ReadBus: Option<HashSet<(BInteger, BInteger)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_T2Reset: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_T2Complete: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_T2ReleaseBus: Option<HashSet<BInteger>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_T2Calculate: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_T2WriteBus: Option<HashSet<(BInteger, BInteger)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_T2Wait: Option<HashSet<BInteger>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_T3Initiate: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_T3Evaluate: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_T3writebus: Option<HashSet<(BInteger, BInteger)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_T3Read: Option<HashSet<(BInteger, BInteger)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_T3Poll: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_T3ReleaseBus: Option<HashSet<BInteger>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_T3Wait: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_T3ReEnableWait: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_Update: Option<HashSet<BInteger>>,}
+
+
+impl CAN_BUS_tlc {
+
+ pub fn new() -> CAN_BUS_tlc {
+ //values: ''
+ let mut m: CAN_BUS_tlc = Default::default();
+ m.init();
+ return m;
+ }
+ fn init(&mut self) {
+ /*set_initializations*///set_initialization
+ self._T1state = bset![T1state, /*enum_call*/T1state::T1_EN, /*enum_call*/T1state::T1_CALC, /*enum_call*/T1state::T1_SEND, /*enum_call*/T1state::T1_WAIT];
+ //set_initialization
+ self._T2mode = bset![T2mode, /*enum_call*/T2mode::T2MODE_SENSE, /*enum_call*/T2mode::T2MODE_TRANSMIT, /*enum_call*/T2mode::T2MODE_RELEASE];
+ //set_initialization
+ self._T2state = bset![T2state, /*enum_call*/T2state::T2_EN, /*enum_call*/T2state::T2_RCV, /*enum_call*/T2state::T2_PROC, /*enum_call*/T2state::T2_CALC, /*enum_call*/T2state::T2_SEND, /*enum_call*/T2state::T2_WAIT, /*enum_call*/T2state::T2_RELEASE];
+ //set_initialization
+ self._T3state = bset![T3state, /*enum_call*/T3state::T3_READY, /*enum_call*/T3state::T3_WRITE, /*enum_call*/T3state::T3_RELEASE, /*enum_call*/T3state::T3_READ, /*enum_call*/T3state::T3_PROC, /*enum_call*/T3state::T3_WAIT];
+ /*properties*///constant_initialization
+ self.NATSET = set_BInteger::interval(&0, &5);
+ /*body*/self.T2v = 0;
+ self.T3_evaluated = true;
+ self.T3_enabled = true;
+ self.T1_state = /*enum_call*/T1state::T1_EN;
+ self.T2_state = /*enum_call*/T2state::T2_EN;
+ self.T3_state = /*enum_call*/T3state::T3_READY;
+ self.T1_writevalue = 0;
+ self.T2_writevalue = 0;
+ self.T2_readvalue = 0;
+ self.T2_readpriority = 0;
+ self.T3_readvalue = 0;
+ self.T3_readpriority = 0;
+ self.T1_timer = 2;
+ self.T2_timer = 3;
+ self.BUSwrite = brel![rel_BInteger_X_BInteger, (0.clone(), 0.clone())].clone().clone();
+ self.BUSvalue = 0;
+ self.BUSpriority = 0;
+ self.T2_mode = /*enum_call*/T2mode::T2MODE_SENSE;
+ /*includesInitialization*/
+ }
+
+ pub fn get_NATSET(&self) -> set_BInteger {
+ return self.NATSET.clone();
+ }
+
+ pub fn get_BUSpriority(&self) -> BInteger {
+ return self.BUSpriority.clone();
+ }
+
+ pub fn get_BUSvalue(&self) -> BInteger {
+ return self.BUSvalue.clone();
+ }
+
+ pub fn get_BUSwrite(&self) -> rel_BInteger_X_BInteger {
+ return self.BUSwrite.clone();
+ }
+
+ pub fn get_T1_state(&self) -> T1state {
+ return self.T1_state.clone();
+ }
+
+ pub fn get_T1_timer(&self) -> BInteger {
+ return self.T1_timer.clone();
+ }
+
+ pub fn get_T1_writevalue(&self) -> BInteger {
+ return self.T1_writevalue.clone();
+ }
+
+ pub fn get_T2_mode(&self) -> T2mode {
+ return self.T2_mode.clone();
+ }
+
+ pub fn get_T2_readpriority(&self) -> BInteger {
+ return self.T2_readpriority.clone();
+ }
+
+ pub fn get_T2_readvalue(&self) -> BInteger {
+ return self.T2_readvalue.clone();
+ }
+
+ pub fn get_T2_state(&self) -> T2state {
+ return self.T2_state.clone();
+ }
+
+ pub fn get_T2_timer(&self) -> BInteger {
+ return self.T2_timer.clone();
+ }
+
+ pub fn get_T2_writevalue(&self) -> BInteger {
+ return self.T2_writevalue.clone();
+ }
+
+ pub fn get_T2v(&self) -> BInteger {
+ return self.T2v.clone();
+ }
+
+ pub fn get_T3_enabled(&self) -> BBoolean {
+ return self.T3_enabled.clone();
+ }
+
+ pub fn get_T3_evaluated(&self) -> BBoolean {
+ return self.T3_evaluated.clone();
+ }
+
+ pub fn get_T3_readpriority(&self) -> BInteger {
+ return self.T3_readpriority.clone();
+ }
+
+ pub fn get_T3_readvalue(&self) -> BInteger {
+ return self.T3_readvalue.clone();
+ }
+
+ pub fn get_T3_state(&self) -> T3state {
+ return self.T3_state.clone();
+ }
+
+ pub fn get__T1state(&self) -> set_T1state {
+ return self._T1state.clone();
+ }
+
+ pub fn get__T2mode(&self) -> set_T2mode {
+ return self._T2mode.clone();
+ }
+
+ pub fn get__T2state(&self) -> set_T2state {
+ return self._T2state.clone();
+ }
+
+ pub fn get__T3state(&self) -> set_T3state {
+ return self._T3state.clone();
+ }
+
+ pub fn T1Evaluate(&mut self) -> () {
+ //pre_assert
+ self.T1_timer = 0;
+ self.T1_state = /*enum_call*/T1state::T1_CALC;
+
+ }
+
+ pub fn T1Calculate(&mut self, mut p: BInteger) -> () {
+ //pre_assert
+ self.T1_writevalue = p;
+ self.T1_state = /*enum_call*/T1state::T1_SEND;
+
+ }
+
+ pub fn T1SendResult(&mut self, mut ppriority: BInteger, mut pv: BInteger) -> () {
+ //pre_assert
+ let mut _ld_BUSwrite = self.BUSwrite.clone();
+ self.BUSwrite = _ld_BUSwrite._override(&brel![rel_BInteger_X_BInteger, (ppriority.clone(), pv.clone())]).clone().clone();
+ self.T1_state = /*enum_call*/T1state::T1_WAIT;
+
+ }
+
+ pub fn T1Wait(&mut self, mut pt: BInteger) -> () {
+ //pre_assert
+ self.T1_timer = pt;
+ self.T1_state = /*enum_call*/T1state::T1_EN;
+
+ }
+
+ pub fn T2Evaluate(&mut self) -> () {
+ //pre_assert
+ self.T2_timer = 0;
+ self.T2_state = /*enum_call*/T2state::T2_RCV;
+
+ }
+
+ pub fn T2ReadBus(&mut self, mut ppriority: BInteger, mut pv: BInteger) -> () {
+ //pre_assert
+ self.T2_readvalue = pv;
+ self.T2_readpriority = ppriority;
+ self.T2_state = /*enum_call*/T2state::T2_PROC;
+
+ }
+
+ pub fn T2Reset(&mut self) -> () {
+ //pre_assert
+ let mut _ld_T2v = self.T2v.clone();
+ self.T2_writevalue = _ld_T2v;
+ self.T2v = 0;
+ self.T2_state = /*enum_call*/T2state::T2_SEND;
+ self.T2_mode = /*enum_call*/T2mode::T2MODE_TRANSMIT;
+
+ }
+
+ pub fn T2Complete(&mut self) -> () {
+ //pre_assert
+ self.T2_state = /*enum_call*/T2state::T2_RELEASE;
+ self.T2_mode = /*enum_call*/T2mode::T2MODE_SENSE;
+
+ }
+
+ pub fn T2ReleaseBus(&mut self, mut ppriority: BInteger) -> () {
+ //pre_assert
+ let mut _ld_BUSwrite = self.BUSwrite.clone();
+ self.BUSwrite = _ld_BUSwrite.domainSubstraction(&bset![BInteger, ppriority]).clone().clone();
+ self.T2_state = /*enum_call*/T2state::T2_WAIT;
+
+ }
+
+ pub fn T2Calculate(&mut self) -> () {
+ //pre_assert
+ self.T2v = self.T2_readvalue;
+ self.T2_state = /*enum_call*/T2state::T2_WAIT;
+
+ }
+
+ pub fn T2WriteBus(&mut self, mut ppriority: BInteger, mut pv: BInteger) -> () {
+ //pre_assert
+ let mut _ld_BUSwrite = self.BUSwrite.clone();
+ self.BUSwrite = _ld_BUSwrite._override(&brel![rel_BInteger_X_BInteger, (ppriority.clone(), pv.clone())]).clone().clone();
+ self.T2_state = /*enum_call*/T2state::T2_WAIT;
+
+ }
+
+ pub fn T2Wait(&mut self, mut pt: BInteger) -> () {
+ //pre_assert
+ self.T2_timer = pt;
+ self.T2_state = /*enum_call*/T2state::T2_EN;
+
+ }
+
+ pub fn T3Initiate(&mut self) -> () {
+ //pre_assert
+ self.T3_state = /*enum_call*/T3state::T3_WRITE;
+ self.T3_enabled = false;
+
+ }
+
+ pub fn T3Evaluate(&mut self) -> () {
+ //pre_assert
+ self.T3_state = /*enum_call*/T3state::T3_READ;
+
+ }
+
+ pub fn T3writebus(&mut self, mut ppriority: BInteger, mut pv: BInteger) -> () {
+ //pre_assert
+ let mut _ld_BUSwrite = self.BUSwrite.clone();
+ self.BUSwrite = _ld_BUSwrite._override(&brel![rel_BInteger_X_BInteger, (ppriority.clone(), pv.clone())]).clone().clone();
+ self.T3_state = /*enum_call*/T3state::T3_WAIT;
+
+ }
+
+ pub fn T3Read(&mut self, mut ppriority: BInteger, mut pv: BInteger) -> () {
+ //pre_assert
+ self.T3_readvalue = pv;
+ self.T3_readpriority = ppriority;
+ self.T3_state = /*enum_call*/T3state::T3_PROC;
+
+ }
+
+ pub fn T3Poll(&mut self) -> () {
+ //pre_assert
+ self.T3_state = /*enum_call*/T3state::T3_WAIT;
+
+ }
+
+ pub fn T3ReleaseBus(&mut self, mut ppriority: BInteger) -> () {
+ //pre_assert
+ let mut _ld_BUSwrite = self.BUSwrite.clone();
+ self.BUSwrite = _ld_BUSwrite.domainSubstraction(&bset![BInteger, ppriority]).clone().clone();
+ self.T3_state = /*enum_call*/T3state::T3_RELEASE;
+
+ }
+
+ pub fn T3Wait(&mut self) -> () {
+ //pre_assert
+ self.T3_state = /*enum_call*/T3state::T3_READY;
+ self.T3_evaluated = true;
+
+ }
+
+ pub fn T3ReEnableWait(&mut self) -> () {
+ //pre_assert
+ self.T3_state = /*enum_call*/T3state::T3_READY;
+ self.T3_evaluated = true;
+ self.T3_enabled = true;
+
+ }
+
+ pub fn Update(&mut self, mut pmax: BInteger) -> () {
+ //pre_assert
+ let mut _ld_T1_timer = self.T1_timer.clone();
+ let mut _ld_T2_timer = self.T2_timer.clone();
+ self.BUSvalue = self.BUSwrite.functionCall(&pmax);
+ self.BUSpriority = pmax;
+ self.T1_timer = _ld_T1_timer.minus(&1);
+ self.T2_timer = _ld_T2_timer.minus(&1);
+ self.T3_evaluated = false;
+
+ }
+
+ pub fn _tr_T1Evaluate(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_T1Evaluate.is_none() {
+ let mut __tmp__val__ = (self.T1_timer.equal(&0) && self.T1_state.equal(&/*enum_call*/T1state::T1_EN));
+ self._tr_cache_T1Evaluate = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_T1Evaluate.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_T1Calculate(&mut self, is_caching: bool) -> HashSet<BInteger> {
+ //transition
+ if !is_caching || self._tr_cache_T1Calculate.is_none() {
+ let mut _ic_set_1: HashSet<BInteger> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_p_1 in set_BInteger::interval(&1.negative(), &3).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if self.T1_state.equal(&/*enum_call*/T1state::T1_CALC) {
+ _ic_set_1.insert(_ic_p_1);
+ }
+
+ }
+ self._tr_cache_T1Calculate = Option::Some(_ic_set_1.clone());
+ return _ic_set_1;
+ } else {
+ return self._tr_cache_T1Calculate.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_T1SendResult(&mut self, is_caching: bool) -> HashSet<(BInteger, BInteger)> {
+ //transition
+ if !is_caching || self._tr_cache_T1SendResult.is_none() {
+ let mut _ic_set_2: HashSet<(BInteger, BInteger)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_assignment
+ {
+ let mut _ic_ppriority_1 = 3;
+ //iteration_construct_assignment
+ {
+ let mut _ic_pv_1 = self.T1_writevalue;
+ //parameter_combination_predicate TODO: FASTER
+ if self.T1_state.equal(&/*enum_call*/T1state::T1_SEND) {
+ _ic_set_2.insert((_ic_ppriority_1.clone(), _ic_pv_1.clone()));
+ }
+
+ }
+ }
+ self._tr_cache_T1SendResult = Option::Some(_ic_set_2.clone());
+ return _ic_set_2;
+ } else {
+ return self._tr_cache_T1SendResult.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_T1Wait(&mut self, is_caching: bool) -> HashSet<BInteger> {
+ //transition
+ if !is_caching || self._tr_cache_T1Wait.is_none() {
+ let mut _ic_set_3: HashSet<BInteger> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_assignment
+ {
+ let mut _ic_pt_1 = 2;
+ //parameter_combination_predicate TODO: FASTER
+ if self.T1_state.equal(&/*enum_call*/T1state::T1_WAIT) {
+ _ic_set_3.insert(_ic_pt_1);
+ }
+
+ }
+ self._tr_cache_T1Wait = Option::Some(_ic_set_3.clone());
+ return _ic_set_3;
+ } else {
+ return self._tr_cache_T1Wait.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_T2Evaluate(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_T2Evaluate.is_none() {
+ let mut __tmp__val__ = (self.T2_timer.equal(&0) && self.T2_state.equal(&/*enum_call*/T2state::T2_EN));
+ self._tr_cache_T2Evaluate = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_T2Evaluate.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_T2ReadBus(&mut self, is_caching: bool) -> HashSet<(BInteger, BInteger)> {
+ //transition
+ if !is_caching || self._tr_cache_T2ReadBus.is_none() {
+ let mut _ic_set_5: HashSet<(BInteger, BInteger)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_assignment
+ {
+ let mut _ic_ppriority_1 = self.BUSpriority;
+ //iteration_construct_assignment
+ {
+ let mut _ic_pv_1 = self.BUSvalue;
+ //parameter_combination_predicate TODO: FASTER
+ if self.T2_state.equal(&/*enum_call*/T2state::T2_RCV) {
+ _ic_set_5.insert((_ic_ppriority_1.clone(), _ic_pv_1.clone()));
+ }
+
+ }
+ }
+ self._tr_cache_T2ReadBus = Option::Some(_ic_set_5.clone());
+ return _ic_set_5;
+ } else {
+ return self._tr_cache_T2ReadBus.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_T2Reset(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_T2Reset.is_none() {
+ let mut __tmp__val__ = (self.T2_readpriority.equal(&4) && self.T2_state.equal(&/*enum_call*/T2state::T2_PROC));
+ self._tr_cache_T2Reset = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_T2Reset.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_T2Complete(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_T2Complete.is_none() {
+ let mut __tmp__val__ = ((self.T2_state.equal(&/*enum_call*/T2state::T2_PROC) && self.T2_readpriority.equal(&5)) && self.T2_mode.equal(&/*enum_call*/T2mode::T2MODE_TRANSMIT));
+ self._tr_cache_T2Complete = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_T2Complete.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_T2ReleaseBus(&mut self, is_caching: bool) -> HashSet<BInteger> {
+ //transition
+ if !is_caching || self._tr_cache_T2ReleaseBus.is_none() {
+ let mut _ic_set_8: HashSet<BInteger> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_assignment
+ {
+ let mut _ic_ppriority_1 = self.T2_readpriority;
+ //parameter_combination_predicate TODO: FASTER
+ if (self.BUSwrite.domain().elementOf(&_ic_ppriority_1) && self.T2_state.equal(&/*enum_call*/T2state::T2_RELEASE)) {
+ _ic_set_8.insert(_ic_ppriority_1);
+ }
+
+ }
+ self._tr_cache_T2ReleaseBus = Option::Some(_ic_set_8.clone());
+ return _ic_set_8;
+ } else {
+ return self._tr_cache_T2ReleaseBus.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_T2Calculate(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_T2Calculate.is_none() {
+ let mut __tmp__val__ = (self.T2_readpriority.equal(&3) && self.T2_state.equal(&/*enum_call*/T2state::T2_PROC));
+ self._tr_cache_T2Calculate = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_T2Calculate.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_T2WriteBus(&mut self, is_caching: bool) -> HashSet<(BInteger, BInteger)> {
+ //transition
+ if !is_caching || self._tr_cache_T2WriteBus.is_none() {
+ let mut _ic_set_10: HashSet<(BInteger, BInteger)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_assignment
+ {
+ let mut _ic_ppriority_1 = 5;
+ //iteration_construct_assignment
+ {
+ let mut _ic_pv_1 = self.T2_writevalue;
+ //parameter_combination_predicate TODO: FASTER
+ if self.T2_state.equal(&/*enum_call*/T2state::T2_SEND) {
+ _ic_set_10.insert((_ic_ppriority_1.clone(), _ic_pv_1.clone()));
+ }
+
+ }
+ }
+ self._tr_cache_T2WriteBus = Option::Some(_ic_set_10.clone());
+ return _ic_set_10;
+ } else {
+ return self._tr_cache_T2WriteBus.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_T2Wait(&mut self, is_caching: bool) -> HashSet<BInteger> {
+ //transition
+ if !is_caching || self._tr_cache_T2Wait.is_none() {
+ let mut _ic_set_11: HashSet<BInteger> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_assignment
+ {
+ let mut _ic_pt_1 = 3;
+ //parameter_combination_predicate TODO: FASTER
+ if self.T2_state.equal(&/*enum_call*/T2state::T2_WAIT) {
+ _ic_set_11.insert(_ic_pt_1);
+ }
+
+ }
+ self._tr_cache_T2Wait = Option::Some(_ic_set_11.clone());
+ return _ic_set_11;
+ } else {
+ return self._tr_cache_T2Wait.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_T3Initiate(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_T3Initiate.is_none() {
+ let mut __tmp__val__ = ((self.T3_state.equal(&/*enum_call*/T3state::T3_READY) && self.T3_evaluated.equal(&false)) && self.T3_enabled.equal(&true));
+ self._tr_cache_T3Initiate = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_T3Initiate.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_T3Evaluate(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_T3Evaluate.is_none() {
+ let mut __tmp__val__ = ((self.T3_state.equal(&/*enum_call*/T3state::T3_READY) && self.T3_evaluated.equal(&false)) && self.T3_enabled.equal(&false));
+ self._tr_cache_T3Evaluate = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_T3Evaluate.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_T3writebus(&mut self, is_caching: bool) -> HashSet<(BInteger, BInteger)> {
+ //transition
+ if !is_caching || self._tr_cache_T3writebus.is_none() {
+ let mut _ic_set_14: HashSet<(BInteger, BInteger)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_assignment
+ {
+ let mut _ic_ppriority_1 = 4;
+ //iteration_construct_assignment
+ {
+ let mut _ic_pv_1 = 0;
+ //parameter_combination_predicate TODO: FASTER
+ if self.T3_state.equal(&/*enum_call*/T3state::T3_WRITE) {
+ _ic_set_14.insert((_ic_ppriority_1.clone(), _ic_pv_1.clone()));
+ }
+
+ }
+ }
+ self._tr_cache_T3writebus = Option::Some(_ic_set_14.clone());
+ return _ic_set_14;
+ } else {
+ return self._tr_cache_T3writebus.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_T3Read(&mut self, is_caching: bool) -> HashSet<(BInteger, BInteger)> {
+ //transition
+ if !is_caching || self._tr_cache_T3Read.is_none() {
+ let mut _ic_set_15: HashSet<(BInteger, BInteger)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_assignment
+ {
+ let mut _ic_ppriority_1 = self.BUSpriority;
+ //iteration_construct_assignment
+ {
+ let mut _ic_pv_1 = self.BUSvalue;
+ //parameter_combination_predicate TODO: FASTER
+ if self.T3_state.equal(&/*enum_call*/T3state::T3_READ) {
+ _ic_set_15.insert((_ic_ppriority_1.clone(), _ic_pv_1.clone()));
+ }
+
+ }
+ }
+ self._tr_cache_T3Read = Option::Some(_ic_set_15.clone());
+ return _ic_set_15;
+ } else {
+ return self._tr_cache_T3Read.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_T3Poll(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_T3Poll.is_none() {
+ let mut __tmp__val__ = (self.T3_readpriority.less(&5) && self.T3_state.equal(&/*enum_call*/T3state::T3_PROC));
+ self._tr_cache_T3Poll = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_T3Poll.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_T3ReleaseBus(&mut self, is_caching: bool) -> HashSet<BInteger> {
+ //transition
+ if !is_caching || self._tr_cache_T3ReleaseBus.is_none() {
+ let mut _ic_set_17: HashSet<BInteger> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_assignment
+ {
+ let mut _ic_ppriority_1 = 4;
+ //parameter_combination_predicate TODO: FASTER
+ if (self.T3_readpriority.equal(&5) && self.T3_state.equal(&/*enum_call*/T3state::T3_PROC)) {
+ _ic_set_17.insert(_ic_ppriority_1);
+ }
+
+ }
+ self._tr_cache_T3ReleaseBus = Option::Some(_ic_set_17.clone());
+ return _ic_set_17;
+ } else {
+ return self._tr_cache_T3ReleaseBus.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_T3Wait(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_T3Wait.is_none() {
+ let mut __tmp__val__ = self.T3_state.equal(&/*enum_call*/T3state::T3_WAIT);
+ self._tr_cache_T3Wait = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_T3Wait.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_T3ReEnableWait(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_T3ReEnableWait.is_none() {
+ let mut __tmp__val__ = self.T3_state.equal(&/*enum_call*/T3state::T3_RELEASE);
+ self._tr_cache_T3ReEnableWait = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_T3ReEnableWait.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_Update(&mut self, is_caching: bool) -> HashSet<BInteger> {
+ //transition
+ if !is_caching || self._tr_cache_Update.is_none() {
+ let mut _ic_set_20: HashSet<BInteger> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_assignment
+ {
+ let mut _ic_pmax_1 = self.BUSwrite.domain()._max();
+ //parameter_combination_predicate TODO: FASTER
+ if ((self.T1_timer.greater(&0) && self.T2_timer.greater(&0)) && (self.T3_enabled.equal(&true) || self.T3_evaluated.equal(&true))) {
+ _ic_set_20.insert(_ic_pmax_1);
+ }
+
+ }
+ self._tr_cache_Update = Option::Some(_ic_set_20.clone());
+ return _ic_set_20;
+ } else {
+ return self._tr_cache_Update.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _check_inv_1(&self) -> bool {
+ //invariant
+ return self.T2v.isInteger();
+ }
+
+ pub fn _check_inv_2(&self) -> bool {
+ //invariant
+ return BOOL.elementOf(&self.T3_evaluated);
+ }
+
+ pub fn _check_inv_3(&self) -> bool {
+ //invariant
+ return BOOL.elementOf(&self.T3_enabled);
+ }
+
+ pub fn _check_inv_4(&self) -> bool {
+ //invariant
+ return self._T1state.elementOf(&self.T1_state);
+ }
+
+ pub fn _check_inv_5(&self) -> bool {
+ //invariant
+ return self._T2state.elementOf(&self.T2_state);
+ }
+
+ pub fn _check_inv_6(&self) -> bool {
+ //invariant
+ return self._T3state.elementOf(&self.T3_state);
+ }
+
+ pub fn _check_inv_7(&self) -> bool {
+ //invariant
+ return self.T1_writevalue.isInteger();
+ }
+
+ pub fn _check_inv_8(&self) -> bool {
+ //invariant
+ return self.T2_writevalue.isInteger();
+ }
+
+ pub fn _check_inv_9(&self) -> bool {
+ //invariant
+ return self.T2_readvalue.isInteger();
+ }
+
+ pub fn _check_inv_10(&self) -> bool {
+ //invariant
+ return self.T1_timer.isNatural();
+ }
+
+ pub fn _check_inv_11(&self) -> bool {
+ //invariant
+ return self.T2_timer.isNatural();
+ }
+
+ pub fn _check_inv_12(&self) -> bool {
+ //invariant
+ return self._T2mode.elementOf(&self.T2_mode);
+ }
+
+ pub fn _check_inv_13(&self) -> bool {
+ //invariant
+ return self.BUSvalue.isInteger();
+ }
+
+ pub fn _check_inv_14(&self) -> bool {
+ //invariant
+ return self.NATSET.elementOf(&self.BUSpriority);
+ }
+
+ pub fn _check_inv_15(&self) -> bool {
+ //invariant
+ return self.T3_readvalue.isInteger();
+ }
+
+ pub fn _check_inv_16(&self) -> bool {
+ //invariant
+ return self.NATSET.elementOf(&self.T3_readpriority);
+ }
+
+ pub fn _check_inv_17(&self) -> bool {
+ //invariant
+ return self.NATSET.elementOf(&self.T2_readpriority);
+ }
+
+ pub fn _check_inv_18(&self) -> bool {
+ //invariant
+ return self.NATSET.check_domain_of(&self.BUSwrite).and(&self.BUSwrite.checkRangeInteger()).and(&self.BUSwrite.isFunction()).and(&self.NATSET.check_partial_of(&self.BUSwrite));
+ }
+
+ pub fn _check_inv_19(&self) -> bool {
+ //invariant
+ return self.BUSwrite.unequal(&brel![rel_BInteger_X_BInteger]);
+ }
+
+ pub fn _check_inv_20(&self) -> bool {
+ //invariant
+ return self.BUSwrite.domain().elementOf(&0);
+ }
+
+ fn invalidate_caches(&mut self, to_invalidate: Vec<&'static str>) {
+ //calling the given functions without caching will recalculate them and cache them afterwards
+ for trans in to_invalidate {
+ match trans {
+ "_tr_T1Evaluate" => {self._tr_T1Evaluate(false);},
+ "_tr_T1Calculate" => {self._tr_T1Calculate(false);},
+ "_tr_T1SendResult" => {self._tr_T1SendResult(false);},
+ "_tr_T1Wait" => {self._tr_T1Wait(false);},
+ "_tr_T2Evaluate" => {self._tr_T2Evaluate(false);},
+ "_tr_T2ReadBus" => {self._tr_T2ReadBus(false);},
+ "_tr_T2Reset" => {self._tr_T2Reset(false);},
+ "_tr_T2Complete" => {self._tr_T2Complete(false);},
+ "_tr_T2ReleaseBus" => {self._tr_T2ReleaseBus(false);},
+ "_tr_T2Calculate" => {self._tr_T2Calculate(false);},
+ "_tr_T2WriteBus" => {self._tr_T2WriteBus(false);},
+ "_tr_T2Wait" => {self._tr_T2Wait(false);},
+ "_tr_T3Initiate" => {self._tr_T3Initiate(false);},
+ "_tr_T3Evaluate" => {self._tr_T3Evaluate(false);},
+ "_tr_T3writebus" => {self._tr_T3writebus(false);},
+ "_tr_T3Read" => {self._tr_T3Read(false);},
+ "_tr_T3Poll" => {self._tr_T3Poll(false);},
+ "_tr_T3ReleaseBus" => {self._tr_T3ReleaseBus(false);},
+ "_tr_T3Wait" => {self._tr_T3Wait(false);},
+ "_tr_T3ReEnableWait" => {self._tr_T3ReEnableWait(false);},
+ "_tr_Update" => {self._tr_Update(false);},
+ _ => {},
+ }
+ }
+ }
+
+ //model_check_next_states
+ fn generateNextStates(state: &mut CAN_BUS_tlc,
+ isCaching: bool,
+ transitions: Arc<AtomicU64>) -> HashSet<(CAN_BUS_tlc, &'static str)> {
+ let mut result = HashSet::<(CAN_BUS_tlc, &'static str)>::new();
+ let mut evaluated_transitions: u64 = 0;
+ //model_check_transition
+ if state._tr_T1Evaluate(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.T1Evaluate();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("T1Evaluate")); }
+ result.insert((copiedState, "T1Evaluate"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_2 = state._tr_T1Calculate(isCaching);
+ for param in _trid_2.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.T1Calculate(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("T1Calculate")); }
+ result.insert((copiedState, "T1Calculate"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_3 = state._tr_T1SendResult(isCaching);
+ for param in _trid_3.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.T1SendResult(_tmp_2, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("T1SendResult")); }
+ result.insert((copiedState, "T1SendResult"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_4 = state._tr_T1Wait(isCaching);
+ for param in _trid_4.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.T1Wait(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("T1Wait")); }
+ result.insert((copiedState, "T1Wait"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_T2Evaluate(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.T2Evaluate();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("T2Evaluate")); }
+ result.insert((copiedState, "T2Evaluate"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_6 = state._tr_T2ReadBus(isCaching);
+ for param in _trid_6.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.T2ReadBus(_tmp_2, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("T2ReadBus")); }
+ result.insert((copiedState, "T2ReadBus"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_T2Reset(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.T2Reset();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("T2Reset")); }
+ result.insert((copiedState, "T2Reset"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_T2Complete(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.T2Complete();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("T2Complete")); }
+ result.insert((copiedState, "T2Complete"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_9 = state._tr_T2ReleaseBus(isCaching);
+ for param in _trid_9.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.T2ReleaseBus(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("T2ReleaseBus")); }
+ result.insert((copiedState, "T2ReleaseBus"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_T2Calculate(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.T2Calculate();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("T2Calculate")); }
+ result.insert((copiedState, "T2Calculate"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_11 = state._tr_T2WriteBus(isCaching);
+ for param in _trid_11.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.T2WriteBus(_tmp_2, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("T2WriteBus")); }
+ result.insert((copiedState, "T2WriteBus"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_12 = state._tr_T2Wait(isCaching);
+ for param in _trid_12.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.T2Wait(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("T2Wait")); }
+ result.insert((copiedState, "T2Wait"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_T3Initiate(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.T3Initiate();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("T3Initiate")); }
+ result.insert((copiedState, "T3Initiate"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_T3Evaluate(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.T3Evaluate();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("T3Evaluate")); }
+ result.insert((copiedState, "T3Evaluate"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_15 = state._tr_T3writebus(isCaching);
+ for param in _trid_15.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.T3writebus(_tmp_2, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("T3writebus")); }
+ result.insert((copiedState, "T3writebus"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_16 = state._tr_T3Read(isCaching);
+ for param in _trid_16.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.T3Read(_tmp_2, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("T3Read")); }
+ result.insert((copiedState, "T3Read"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_T3Poll(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.T3Poll();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("T3Poll")); }
+ result.insert((copiedState, "T3Poll"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_18 = state._tr_T3ReleaseBus(isCaching);
+ for param in _trid_18.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.T3ReleaseBus(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("T3ReleaseBus")); }
+ result.insert((copiedState, "T3ReleaseBus"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_T3Wait(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.T3Wait();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("T3Wait")); }
+ result.insert((copiedState, "T3Wait"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_T3ReEnableWait(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.T3ReEnableWait();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("T3ReEnableWait")); }
+ result.insert((copiedState, "T3ReEnableWait"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_21 = state._tr_Update(isCaching);
+ for param in _trid_21.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.Update(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("Update")); }
+ result.insert((copiedState, "Update"));
+ evaluated_transitions += 1;
+ }
+
+
+ transitions.fetch_add(evaluated_transitions, Ordering::AcqRel);
+ return result;
+ }
+
+ //model_check_invariants
+ pub fn checkInvariants(state: &CAN_BUS_tlc, last_op: &'static str, isCaching: bool) -> bool {
+ if isCaching {
+ let dependent_invariants_of_state = Self::get_invariant_dependencies(last_op);
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_1") {
+ if !state._check_inv_1() {
+ println!("_check_inv_1 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_2") {
+ if !state._check_inv_2() {
+ println!("_check_inv_2 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_3") {
+ if !state._check_inv_3() {
+ println!("_check_inv_3 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_4") {
+ if !state._check_inv_4() {
+ println!("_check_inv_4 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_5") {
+ if !state._check_inv_5() {
+ println!("_check_inv_5 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_6") {
+ if !state._check_inv_6() {
+ println!("_check_inv_6 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_7") {
+ if !state._check_inv_7() {
+ println!("_check_inv_7 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_8") {
+ if !state._check_inv_8() {
+ println!("_check_inv_8 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_9") {
+ if !state._check_inv_9() {
+ println!("_check_inv_9 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_10") {
+ if !state._check_inv_10() {
+ println!("_check_inv_10 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_11") {
+ if !state._check_inv_11() {
+ println!("_check_inv_11 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_12") {
+ if !state._check_inv_12() {
+ println!("_check_inv_12 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_13") {
+ if !state._check_inv_13() {
+ println!("_check_inv_13 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_14") {
+ if !state._check_inv_14() {
+ println!("_check_inv_14 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_15") {
+ if !state._check_inv_15() {
+ println!("_check_inv_15 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_16") {
+ if !state._check_inv_16() {
+ println!("_check_inv_16 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_17") {
+ if !state._check_inv_17() {
+ println!("_check_inv_17 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_18") {
+ if !state._check_inv_18() {
+ println!("_check_inv_18 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_19") {
+ if !state._check_inv_19() {
+ println!("_check_inv_19 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_20") {
+ if !state._check_inv_20() {
+ println!("_check_inv_20 failed!");
+ return false;
+ }
+ }
+ return true;
+ }
+ return !(!state._check_inv_1() || !state._check_inv_2() || !state._check_inv_3() || !state._check_inv_4() || !state._check_inv_5() || !state._check_inv_6() || !state._check_inv_7() || !state._check_inv_8() || !state._check_inv_9() || !state._check_inv_10() || !state._check_inv_11() || !state._check_inv_12() || !state._check_inv_13() || !state._check_inv_14() || !state._check_inv_15() || !state._check_inv_16() || !state._check_inv_17() || !state._check_inv_18() || !state._check_inv_19() || !state._check_inv_20());
+ }
+
+ //model_check_print
+ fn print_result(states: usize, transitions: u64, error_detected: bool) {
+ if !error_detected { println!("MODEL CHECKING SUCCESSFUL"); }
+ println!("Number of States: {}", states);
+ println!("Number of Transitions: {}", transitions);
+ }
+
+ //model_check_main
+ fn next(collection_m: Arc<Mutex<LinkedList<(CAN_BUS_tlc, &'static str)>>>, mc_type: MC_TYPE) -> (CAN_BUS_tlc, &'static str) {
+ let mut collection = collection_m.lock().unwrap();
+ return match mc_type {
+ MC_TYPE::BFS => collection.pop_front().unwrap(),
+ MC_TYPE::DFS => collection.pop_back().unwrap(),
+ MC_TYPE::MIXED => if collection.len() % 2 == 0 { collection.pop_front().unwrap() } else { collection.pop_back().unwrap() }
+ };
+ }
+
+ fn get_guard_dependencies(op: &'static str) -> Vec<&str> {
+ return match op {
+ //model_check_init_static
+ "T1Wait" => vec!["_tr_T1Evaluate", "_tr_Update", "_tr_T1SendResult", "_tr_T1Calculate", "_tr_T1Wait"],
+ //model_check_init_static
+ "T1Calculate" => vec!["_tr_T1Evaluate", "_tr_T1SendResult", "_tr_T1Calculate", "_tr_T1Wait"],
+ //model_check_init_static
+ "T1SendResult" => vec!["_tr_T1Evaluate", "_tr_T2ReleaseBus", "_tr_Update", "_tr_T1SendResult", "_tr_T1Calculate", "_tr_T1Wait"],
+ //model_check_init_static
+ "T2ReadBus" => vec!["_tr_T2Reset", "_tr_T2ReleaseBus", "_tr_T2Complete", "_tr_T2Calculate", "_tr_T2Evaluate", "_tr_T2ReadBus", "_tr_T2WriteBus", "_tr_T2Wait"],
+ //model_check_init_static
+ "T2Reset" => vec!["_tr_T2Reset", "_tr_T2ReleaseBus", "_tr_T2Complete", "_tr_T2Calculate", "_tr_T2Evaluate", "_tr_T2ReadBus", "_tr_T2WriteBus", "_tr_T2Wait"],
+ //model_check_init_static
+ "T2Complete" => vec!["_tr_T2Reset", "_tr_T2ReleaseBus", "_tr_T2Complete", "_tr_T2Calculate", "_tr_T2Evaluate", "_tr_T2ReadBus", "_tr_T2WriteBus", "_tr_T2Wait"],
+ //model_check_init_static
+ "T2Evaluate" => vec!["_tr_T2Reset", "_tr_T2ReleaseBus", "_tr_T2Complete", "_tr_T2Calculate", "_tr_T2Evaluate", "_tr_Update", "_tr_T2ReadBus", "_tr_T2WriteBus", "_tr_T2Wait"],
+ //model_check_init_static
+ "T3Evaluate" => vec!["_tr_T3writebus", "_tr_T3Read", "_tr_T3ReleaseBus", "_tr_T3Poll", "_tr_T3ReEnableWait", "_tr_T3Evaluate", "_tr_T3Wait", "_tr_T3Initiate"],
+ //model_check_init_static
+ "T3ReleaseBus" => vec!["_tr_T2ReleaseBus", "_tr_T3writebus", "_tr_T3Read", "_tr_T3ReleaseBus", "_tr_T3Poll", "_tr_Update", "_tr_T3ReEnableWait", "_tr_T3Evaluate", "_tr_T3Wait", "_tr_T3Initiate"],
+ //model_check_init_static
+ "T1Evaluate" => vec!["_tr_T1Evaluate", "_tr_Update", "_tr_T1SendResult", "_tr_T1Calculate", "_tr_T1Wait"],
+ //model_check_init_static
+ "T3Initiate" => vec!["_tr_T3writebus", "_tr_T3Read", "_tr_T3ReleaseBus", "_tr_T3Poll", "_tr_Update", "_tr_T3ReEnableWait", "_tr_T3Evaluate", "_tr_T3Wait", "_tr_T3Initiate"],
+ //model_check_init_static
+ "T3ReEnableWait" => vec!["_tr_T3writebus", "_tr_T3Read", "_tr_T3ReleaseBus", "_tr_T3Poll", "_tr_Update", "_tr_T3ReEnableWait", "_tr_T3Evaluate", "_tr_T3Wait", "_tr_T3Initiate"],
+ //model_check_init_static
+ "T3writebus" => vec!["_tr_T2ReleaseBus", "_tr_T3writebus", "_tr_T3Read", "_tr_T3ReleaseBus", "_tr_T3Poll", "_tr_Update", "_tr_T3ReEnableWait", "_tr_T3Evaluate", "_tr_T3Wait", "_tr_T3Initiate"],
+ //model_check_init_static
+ "Update" => vec!["_tr_T1Evaluate", "_tr_T3Read", "_tr_T2Evaluate", "_tr_Update", "_tr_T2ReadBus", "_tr_T3Evaluate", "_tr_T3Initiate"],
+ //model_check_init_static
+ "T2ReleaseBus" => vec!["_tr_T2Reset", "_tr_T2ReleaseBus", "_tr_T2Complete", "_tr_T2Calculate", "_tr_T2Evaluate", "_tr_Update", "_tr_T2ReadBus", "_tr_T2WriteBus", "_tr_T2Wait"],
+ //model_check_init_static
+ "T2Wait" => vec!["_tr_T2Reset", "_tr_T2ReleaseBus", "_tr_T2Complete", "_tr_T2Calculate", "_tr_T2Evaluate", "_tr_Update", "_tr_T2ReadBus", "_tr_T2WriteBus", "_tr_T2Wait"],
+ //model_check_init_static
+ "T3Poll" => vec!["_tr_T3writebus", "_tr_T3Read", "_tr_T3ReleaseBus", "_tr_T3Poll", "_tr_T3ReEnableWait", "_tr_T3Evaluate", "_tr_T3Wait", "_tr_T3Initiate"],
+ //model_check_init_static
+ "T2Calculate" => vec!["_tr_T2Reset", "_tr_T2ReleaseBus", "_tr_T2Complete", "_tr_T2Calculate", "_tr_T2Evaluate", "_tr_T2ReadBus", "_tr_T2WriteBus", "_tr_T2Wait"],
+ //model_check_init_static
+ "T3Read" => vec!["_tr_T3writebus", "_tr_T3Read", "_tr_T3ReleaseBus", "_tr_T3Poll", "_tr_T3ReEnableWait", "_tr_T3Evaluate", "_tr_T3Wait", "_tr_T3Initiate"],
+ //model_check_init_static
+ "T3Wait" => vec!["_tr_T3writebus", "_tr_T3Read", "_tr_T3ReleaseBus", "_tr_T3Poll", "_tr_Update", "_tr_T3ReEnableWait", "_tr_T3Evaluate", "_tr_T3Wait", "_tr_T3Initiate"],
+ //model_check_init_static
+ "T2WriteBus" => vec!["_tr_T2Reset", "_tr_T2ReleaseBus", "_tr_T2Complete", "_tr_T2Calculate", "_tr_T2Evaluate", "_tr_Update", "_tr_T2ReadBus", "_tr_T2WriteBus", "_tr_T2Wait"],
+ _ => vec![],
+ }
+ }
+
+ fn get_invariant_dependencies(op: &'static str) -> Vec<&str> {
+ return match op {
+ //model_check_init_static
+ "T1Wait" => vec!["_check_inv_10", "_check_inv_4"],
+ //model_check_init_static
+ "T1Calculate" => vec!["_check_inv_7", "_check_inv_4"],
+ //model_check_init_static
+ "T1SendResult" => vec!["_check_inv_18", "_check_inv_19", "_check_inv_20", "_check_inv_4"],
+ //model_check_init_static
+ "T2ReadBus" => vec!["_check_inv_17", "_check_inv_5", "_check_inv_9"],
+ //model_check_init_static
+ "T2Reset" => vec!["_check_inv_1", "_check_inv_5", "_check_inv_8", "_check_inv_12"],
+ //model_check_init_static
+ "T2Complete" => vec!["_check_inv_5", "_check_inv_12"],
+ //model_check_init_static
+ "T2Evaluate" => vec!["_check_inv_5", "_check_inv_11"],
+ //model_check_init_static
+ "T3Evaluate" => vec!["_check_inv_6"],
+ //model_check_init_static
+ "T3ReleaseBus" => vec!["_check_inv_18", "_check_inv_19", "_check_inv_6", "_check_inv_20"],
+ //model_check_init_static
+ "T1Evaluate" => vec!["_check_inv_10", "_check_inv_4"],
+ //model_check_init_static
+ "T3Initiate" => vec!["_check_inv_3", "_check_inv_6"],
+ //model_check_init_static
+ "T3ReEnableWait" => vec!["_check_inv_2", "_check_inv_3", "_check_inv_6"],
+ //model_check_init_static
+ "T3writebus" => vec!["_check_inv_18", "_check_inv_19", "_check_inv_6", "_check_inv_20"],
+ //model_check_init_static
+ "Update" => vec!["_check_inv_2", "_check_inv_10", "_check_inv_14", "_check_inv_13", "_check_inv_11"],
+ //model_check_init_static
+ "T2ReleaseBus" => vec!["_check_inv_18", "_check_inv_19", "_check_inv_20", "_check_inv_5"],
+ //model_check_init_static
+ "T2Wait" => vec!["_check_inv_5", "_check_inv_11"],
+ //model_check_init_static
+ "T3Poll" => vec!["_check_inv_6"],
+ //model_check_init_static
+ "T2Calculate" => vec!["_check_inv_1", "_check_inv_5"],
+ //model_check_init_static
+ "T3Read" => vec!["_check_inv_16", "_check_inv_15", "_check_inv_6"],
+ //model_check_init_static
+ "T3Wait" => vec!["_check_inv_2", "_check_inv_6"],
+ //model_check_init_static
+ "T2WriteBus" => vec!["_check_inv_18", "_check_inv_19", "_check_inv_20", "_check_inv_5"],
+ _ => vec![],
+ }
+ }
+
+ fn model_check_single_threaded(mc_type: MC_TYPE, is_caching: bool, no_dead: bool, no_inv: bool) {
+ let mut machine = CAN_BUS_tlc::new();
+
+ let mut all_states = HashSet::<CAN_BUS_tlc>::new();
+ all_states.insert(machine.clone());
+
+ let states_to_process_mutex = Arc::new(Mutex::new(LinkedList::<(CAN_BUS_tlc, &'static str)>::new()));
+ states_to_process_mutex.lock().unwrap().push_back((machine.clone(), ""));
+
+ let num_transitions = Arc::new(AtomicU64::new(0));
+
+ let mut stop_threads = false;
+
+ while !stop_threads && !states_to_process_mutex.lock().unwrap().is_empty() {
+ let (mut state, last_op) = Self::next(Arc::clone(&states_to_process_mutex), mc_type);
+
+ let next_states = Self::generateNextStates(&mut state, is_caching, Arc::clone(&num_transitions));
+
+ if !no_inv && !Self::checkInvariants(&state, last_op, is_caching) {
+ println!("INVARIANT VIOLATED");
+ stop_threads = true;
+ }
+ if !no_dead && next_states.is_empty() {
+ print!("DEADLOCK DETECTED");
+ stop_threads = true;
+ }
+
+ next_states.into_iter()
+ .filter(|(next_state, _)| all_states.insert((*next_state).clone()))
+ .for_each(|(next_state, last_op)| states_to_process_mutex.lock().unwrap().push_back((next_state, last_op)));
+
+ if all_states.len() % 50000 == 0 {
+ println!("VISITED STATES: {}", all_states.len());
+ println!("EVALUATED TRANSITIONS: {}", num_transitions.load(Ordering::Acquire));
+ println!("-------------------");
+ }
+ }
+ Self::print_result(all_states.len(), num_transitions.load(Ordering::Acquire), stop_threads);
+ }
+
+ fn modelCheckMultiThreaded(mc_type: MC_TYPE, threads: usize, is_caching: bool, no_dead: bool, no_inv: bool) {
+ let threadPool = ThreadPool::new(threads);
+
+ let machine = CAN_BUS_tlc::new();
+
+ let all_states = Arc::new(DashSet::<CAN_BUS_tlc>::new());
+ all_states.insert(machine.clone());
+
+ let states_to_process_mutex = Arc::new(Mutex::new(LinkedList::<(CAN_BUS_tlc, &'static str)>::new()));
+ states_to_process_mutex.lock().unwrap().push_back((machine, ""));
+
+ let num_transitions = Arc::new(AtomicU64::new(0));
+
+ let mut stop_threads = false;
+ let mut spawned_tasks: u64 = 0;
+ let mut finished_tasks: u64 = 0;
+
+ let (tx, rx) = channel();
+ //println!("Thread {:?} starting threads", thread::current().id());
+ while !stop_threads && !states_to_process_mutex.lock().unwrap().is_empty() {
+ let (mut state, last_op) = Self::next(Arc::clone(&states_to_process_mutex), mc_type);
+
+ let states_to_process = Arc::clone(&states_to_process_mutex);
+ let transitions = Arc::clone(&num_transitions);
+ let states = Arc::clone(&all_states);
+ let tx = tx.clone();
+ //println!("Thread {:?} spawning a thread", thread::current().id());
+ threadPool.execute(move|| {
+ let next_states = Self::generateNextStates(&mut state, is_caching, transitions);
+ if !no_dead && next_states.is_empty() { let _ = tx.send(Err("DEADLOCK DETECTED")); }
+
+ //println!("Thread {:?} executing", thread::current().id());
+ next_states.into_iter()
+ .filter(|(next_state, _)| states.insert((*next_state).clone()))
+ .for_each(|(next_state, last_op)| states_to_process.lock().unwrap().push_back((next_state, last_op)));
+
+ if !no_inv && !Self::checkInvariants(&state, last_op, is_caching) {
+ let _ = tx.send(Err("INVARIANT VIOLATED"));
+ }
+ //println!("Thread {:?} done", thread::current().id());
+ let _ = tx.send(Ok(1));
+ });
+
+ spawned_tasks += 1;
+ if spawned_tasks % 50000 == 0 {
+ println!("VISITED STATES: {}", all_states.len());
+ println!("EVALUATED TRANSITIONS: {}", num_transitions.load(Ordering::Acquire));
+ println!("-------------------");
+ }
+
+ while states_to_process_mutex.lock().unwrap().is_empty() && spawned_tasks - finished_tasks > 0 {
+ //println!("Thread {:?} (main) waiting for a thread to finish", thread::current().id());
+ match rx.try_recv() {
+ Ok(val) => match val {
+ Ok(_) => finished_tasks += 1,
+ Err(msg) => { println!("{}", msg); stop_threads = true; },
+ },
+ Err(_) => (),
+ }
+ if threadPool.panic_count() > 0 { stop_threads = true; }
+ }
+ }
+
+ Self::print_result(all_states.len(), num_transitions.load(Ordering::Acquire), stop_threads);
+ }
+
+}
+
+
+fn main() {
+ let args: Vec<String> = env::args().collect();
+ if args.len() < 4 { panic!("Number of arguments errorneous"); }
+
+ let threads = args.get(2).unwrap().parse::<usize>().unwrap();
+ if threads <= 0 { panic!("Input for number of threads is wrong."); }
+
+ let is_caching = args.get(3).unwrap().parse::<bool>().unwrap();
+ let mc_type = match args.get(1).unwrap().as_str() {
+ "mixed" => MC_TYPE::MIXED,
+ "bf" => MC_TYPE::BFS,
+ "df" => MC_TYPE::DFS,
+ _ => panic!("Input for strategy is wrong.")
+ };
+
+ let mut no_dead = false;
+ let mut no_inv = false;
+
+ if args.len() > 4 {
+ for arg in args.iter().skip(4) {
+ match arg.as_str() {
+ "-nodead" => no_dead = true,
+ "-noinv" => no_inv = true,
+ _ => {}
+ }
+ }
+ }
+
+ if threads == 1 {
+ CAN_BUS_tlc::model_check_single_threaded(mc_type, is_caching, no_dead, no_inv);
+ } else {
+ CAN_BUS_tlc::modelCheckMultiThreaded(mc_type, threads, is_caching, no_dead, no_inv);
+ }
+}
diff --git a/benchmarks/model_checking/Rust_embedded/Cruise_finite1_deterministic_MC.rs b/benchmarks/model_checking/Rust_embedded/Cruise_finite1_deterministic_MC.rs
new file mode 100644
index 000000000..ce8b06988
--- /dev/null
+++ b/benchmarks/model_checking/Rust_embedded/Cruise_finite1_deterministic_MC.rs
@@ -0,0 +1,2011 @@
+#![ allow( dead_code, unused, non_snake_case, non_camel_case_types, unused_assignments ) ]
+//#![no_std] //std is enabled for the generated machine by default, since without it there is no println which makes unit-testing very difficult
+use btypes::{bset, brel};
+use btypes::bset::BSet;
+use btypes::bset::SetItem;
+use btypes::bset::PowSetItem;
+use btypes::bset::PowAble;
+use btypes::bset::NestedSet;
+use btypes::brelation::BRelation;
+use btypes::brelation::RelLeftItem;
+use btypes::brelation::RelPowAble;
+use btypes::bboolean::BBoolean;
+use btypes::bboolean::BBool;
+use btypes::bboolean::BOOL;
+use btypes::binteger::BInteger;
+use btypes::binteger::BInt;
+use btypes::binteger::set_BInteger;
+use btypes::btuple::BTuple;
+
+use std::env;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, mpsc, Mutex};
+use std::collections::{HashSet, LinkedList};
+use dashmap::DashSet;
+use threadpool::ThreadPool;
+use std::sync::mpsc::channel;
+use derivative::Derivative;
+use std::time::{Duration};
+
+
+
+#[derive(Clone, Copy)]
+pub enum MC_TYPE { BFS, DFS, MIXED }
+
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum RSset {
+ #[default]
+ RSnone = 0,
+ RSpos = 1,
+ RSneg = 2,
+ RSequal = 3
+}
+
+impl RSset {
+ pub fn equal(&self, other: &RSset) -> bool { *self == *other }
+ pub fn unequal(&self, other: &RSset) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::RSnone,
+ 1 => Self::RSpos,
+ 2 => Self::RSneg,
+ 3 => Self::RSequal,
+ _ => panic!("RSset index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<4> for RSset {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_RSset = BSet<RSset, 4>;
+//set_enum_declaration done
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum ODset {
+ #[default]
+ ODnone = 0,
+ ODclose = 1,
+ ODveryclose = 2
+}
+
+impl ODset {
+ pub fn equal(&self, other: &ODset) -> bool { *self == *other }
+ pub fn unequal(&self, other: &ODset) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::ODnone,
+ 1 => Self::ODclose,
+ 2 => Self::ODveryclose,
+ _ => panic!("ODset index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<3> for ODset {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_ODset = BSet<ODset, 3>;
+//set_enum_declaration done
+
+
+#[derive(Derivative)]
+#[derivative(Clone, Default, Debug, Hash, PartialEq, Eq)]
+pub struct Cruise_finite1_deterministic_MC {
+ /*declarations*/CruiseAllowed: BBoolean,
+ CruiseActive: BBoolean,
+ VehicleAtCruiseSpeed: BBoolean,
+ VehicleCanKeepSpeed: BBoolean,
+ VehicleTryKeepSpeed: BBoolean,
+ SpeedAboveMax: BBoolean,
+ VehicleTryKeepTimeGap: BBoolean,
+ CruiseSpeedAtMax: BBoolean,
+ ObstaclePresent: BBoolean,
+ ObstacleDistance: ODset,
+ ObstacleRelativeSpeed: RSset,
+ ObstacleStatusJustChanged: BBoolean,
+ CCInitialisationInProgress: BBoolean,
+ CruiseSpeedChangeInProgress: BBoolean,
+ NumberOfSetCruise: BInteger,
+ /*sets*//*set_declaration*/_RSset: set_RSset,
+ /*set_declaration*/_ODset: set_ODset,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_CruiseBecomesNotAllowed: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_CruiseBecomesAllowed: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_SetCruiseSpeed: Option<HashSet<(BBoolean, BBoolean)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_CCInitialisationFinished: Option<HashSet<(BBoolean, BBoolean)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_CCInitialisationDelayFinished: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_CruiseSpeedChangeFinished: Option<HashSet<(BBoolean, BBoolean)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_CruiseSpeedChangeDelayFinished: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_CruiseOff: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_ExternalForcesBecomesExtreme: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_ExternalForcesBecomesNormal: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_VehicleLeavesCruiseSpeed: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_VehicleReachesCruiseSpeed: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_VehicleExceedsMaxCruiseSpeed: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_VehicleFallsBelowMaxCruiseSpeed: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_ObstacleDistanceBecomesVeryClose: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_ObstacleDistanceBecomesClose: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_ObstacleDistanceBecomesBig: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_ObstacleStartsTravelFaster: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_ObstacleStopsTravelFaster: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_ObstacleStartsTravelSlower: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_ObstacleStopsTravelSlower: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_ObstacleAppearsWhenCruiseActive: Option<HashSet<(RSset, ODset)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_ObstacleAppearsWhenCruiseInactive: Option<HashSet<RSset>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_ObstacleDisappears: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_VehicleManageObstacle: Option<HashSet<(BBoolean, BBoolean)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_ObstacleBecomesOld: Option<bool>,}
+
+
+impl Cruise_finite1_deterministic_MC {
+
+ pub fn new() -> Cruise_finite1_deterministic_MC {
+ //values: ''
+ let mut m: Cruise_finite1_deterministic_MC = Default::default();
+ m.init();
+ return m;
+ }
+ fn init(&mut self) {
+ /*set_initializations*///set_initialization
+ self._RSset = bset![RSset, /*enum_call*/RSset::RSnone, /*enum_call*/RSset::RSpos, /*enum_call*/RSset::RSneg, /*enum_call*/RSset::RSequal];
+ //set_initialization
+ self._ODset = bset![ODset, /*enum_call*/ODset::ODnone, /*enum_call*/ODset::ODclose, /*enum_call*/ODset::ODveryclose];
+ /*properties*/
+ /*body*/self.CruiseAllowed = true;
+ self.CruiseActive = false;
+ self.VehicleAtCruiseSpeed = false;
+ self.VehicleCanKeepSpeed = false;
+ self.VehicleTryKeepSpeed = false;
+ self.SpeedAboveMax = false;
+ self.VehicleTryKeepTimeGap = false;
+ self.NumberOfSetCruise = 0;
+ self.CruiseSpeedAtMax = false;
+ self.ObstacleDistance = /*enum_call*/ODset::ODnone;
+ self.ObstacleStatusJustChanged = false;
+ self.CCInitialisationInProgress = false;
+ self.CruiseSpeedChangeInProgress = false;
+ self.ObstaclePresent = false;
+ self.ObstacleRelativeSpeed = /*enum_call*/RSset::RSnone;
+ /*includesInitialization*/
+ }
+
+ pub fn get_CruiseAllowed(&self) -> BBoolean {
+ return self.CruiseAllowed.clone();
+ }
+
+ pub fn get_CruiseActive(&self) -> BBoolean {
+ return self.CruiseActive.clone();
+ }
+
+ pub fn get_VehicleAtCruiseSpeed(&self) -> BBoolean {
+ return self.VehicleAtCruiseSpeed.clone();
+ }
+
+ pub fn get_VehicleCanKeepSpeed(&self) -> BBoolean {
+ return self.VehicleCanKeepSpeed.clone();
+ }
+
+ pub fn get_VehicleTryKeepSpeed(&self) -> BBoolean {
+ return self.VehicleTryKeepSpeed.clone();
+ }
+
+ pub fn get_SpeedAboveMax(&self) -> BBoolean {
+ return self.SpeedAboveMax.clone();
+ }
+
+ pub fn get_VehicleTryKeepTimeGap(&self) -> BBoolean {
+ return self.VehicleTryKeepTimeGap.clone();
+ }
+
+ pub fn get_CruiseSpeedAtMax(&self) -> BBoolean {
+ return self.CruiseSpeedAtMax.clone();
+ }
+
+ pub fn get_ObstaclePresent(&self) -> BBoolean {
+ return self.ObstaclePresent.clone();
+ }
+
+ pub fn get_ObstacleDistance(&self) -> ODset {
+ return self.ObstacleDistance.clone();
+ }
+
+ pub fn get_ObstacleRelativeSpeed(&self) -> RSset {
+ return self.ObstacleRelativeSpeed.clone();
+ }
+
+ pub fn get_ObstacleStatusJustChanged(&self) -> BBoolean {
+ return self.ObstacleStatusJustChanged.clone();
+ }
+
+ pub fn get_CCInitialisationInProgress(&self) -> BBoolean {
+ return self.CCInitialisationInProgress.clone();
+ }
+
+ pub fn get_CruiseSpeedChangeInProgress(&self) -> BBoolean {
+ return self.CruiseSpeedChangeInProgress.clone();
+ }
+
+ pub fn get_NumberOfSetCruise(&self) -> BInteger {
+ return self.NumberOfSetCruise.clone();
+ }
+
+ pub fn get__RSset(&self) -> set_RSset {
+ return self._RSset.clone();
+ }
+
+ pub fn get__ODset(&self) -> set_ODset {
+ return self._ODset.clone();
+ }
+
+ pub fn CruiseBecomesNotAllowed(&mut self) -> () {
+ //select
+ if self.CruiseAllowed.equal(&true) {
+ self.CruiseAllowed = false;
+ self.CruiseActive = false;
+ self.VehicleCanKeepSpeed = false;
+ self.VehicleTryKeepSpeed = false;
+ self.VehicleAtCruiseSpeed = false;
+ self.VehicleTryKeepTimeGap = false;
+ self.CruiseSpeedAtMax = false;
+ self.ObstacleDistance = /*enum_call*/ODset::ODnone;
+ self.NumberOfSetCruise = 0;
+ self.ObstacleStatusJustChanged = false;
+ self.CCInitialisationInProgress = false;
+ self.CruiseSpeedChangeInProgress = false;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn CruiseBecomesAllowed(&mut self) -> () {
+ //select
+ if self.CruiseAllowed.equal(&false) {
+ self.CruiseAllowed = true;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn SetCruiseSpeed(&mut self, mut vcks: BBoolean, mut csam: BBoolean) -> () {
+ //pre_assert
+ let mut _ld_NumberOfSetCruise = self.NumberOfSetCruise.clone();
+ let mut _ld_CruiseActive = self.CruiseActive.clone();
+ self.CruiseActive = true;
+ self.VehicleCanKeepSpeed = vcks;
+ //if
+ if self.SpeedAboveMax.equal(&false) {
+ self.VehicleAtCruiseSpeed = true;
+ self.CruiseSpeedAtMax = csam;
+ } //else
+ else {
+ self.CruiseSpeedAtMax = true;
+ }
+ self.ObstacleStatusJustChanged = true;
+ //if
+ if _ld_CruiseActive.equal(&true) {
+ self.CruiseSpeedChangeInProgress = true;
+ } //else
+ else {
+ self.CCInitialisationInProgress = true;
+ }
+ //if
+ if _ld_NumberOfSetCruise.less(&1) {
+ self.NumberOfSetCruise = _ld_NumberOfSetCruise.plus(&1);
+ }
+
+ }
+
+ pub fn CCInitialisationFinished(&mut self, mut vtks: BBoolean, mut vtktg: BBoolean) -> () {
+ //pre_assert
+ self.VehicleTryKeepTimeGap = vtktg;
+ self.VehicleTryKeepSpeed = vtks;
+
+ }
+
+ pub fn CCInitialisationDelayFinished(&mut self) -> () {
+ //select
+ if (((((self.CCInitialisationInProgress.equal(&true) && (((self.VehicleTryKeepSpeed.equal(&true) || self.VehicleTryKeepTimeGap.equal(&true)) || self.ObstacleStatusJustChanged.equal(&true)) || self.CruiseSpeedChangeInProgress.equal(&true))) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone).implies(|| self.VehicleTryKeepSpeed.equal(&true))) && (((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODclose) && self.ObstacleRelativeSpeed.unequal(&/*enum_call*/RSset::RSpos)) && self.ObstacleStatusJustChanged.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| self.VehicleTryKeepTimeGap.equal(&true))) && ((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODveryclose) && self.ObstacleStatusJustChanged.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| self.VehicleTryKeepTimeGap.equal(&true))) && (((self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos) && self.ObstacleDistance.unequal(&/*enum_call*/ODset::ODveryclose)) && self.ObstacleStatusJustChanged.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| self.VehicleTryKeepSpeed.equal(&true))) {
+ self.CCInitialisationInProgress = true;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn CruiseSpeedChangeFinished(&mut self, mut vtks: BBoolean, mut vtktg: BBoolean) -> () {
+ //select
+ if (((((((((((BOOL.elementOf(&vtks) && BOOL.elementOf(&vtktg)) && (((vtks.equal(&true) || vtktg.equal(&true)) || self.ObstacleStatusJustChanged.equal(&true)) || self.CCInitialisationInProgress.equal(&true))) && self.ObstaclePresent.equal(&false).implies(|| vtktg.equal(&false))) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone).implies(|| vtks.equal(&true))) && (((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODclose) && self.ObstacleRelativeSpeed.unequal(&/*enum_call*/RSset::RSpos)) && self.ObstacleStatusJustChanged.equal(&false)) && self.CCInitialisationInProgress.equal(&false)).implies(|| vtktg.equal(&true))) && ((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODveryclose) && self.ObstacleStatusJustChanged.equal(&false)) && self.CCInitialisationInProgress.equal(&false)).implies(|| vtktg.equal(&true))) && (((self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos) && self.ObstacleDistance.unequal(&/*enum_call*/ODset::ODveryclose)) && self.ObstacleStatusJustChanged.equal(&false)) && self.CCInitialisationInProgress.equal(&false)).implies(|| vtks.equal(&true))) && (self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSequal) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone)).implies(|| vtktg.equal(&false))) && (self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSneg) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone)).implies(|| vtktg.equal(&false))) && (self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos) && self.ObstacleDistance.unequal(&/*enum_call*/ODset::ODveryclose)).implies(|| vtktg.equal(&false))) && self.CruiseSpeedChangeInProgress.equal(&true)) {
+ self.VehicleTryKeepTimeGap = vtktg;
+ self.VehicleTryKeepSpeed = vtks;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn CruiseSpeedChangeDelayFinished(&mut self) -> () {
+ //select
+ if (((((self.CruiseSpeedChangeInProgress.equal(&true) && (((self.VehicleTryKeepSpeed.equal(&true) || self.VehicleTryKeepTimeGap.equal(&true)) || self.ObstacleStatusJustChanged.equal(&true)) || self.CCInitialisationInProgress.equal(&true))) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone).implies(|| self.VehicleTryKeepSpeed.equal(&true))) && (((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODclose) && self.ObstacleRelativeSpeed.unequal(&/*enum_call*/RSset::RSpos)) && self.ObstacleStatusJustChanged.equal(&false)) && self.CCInitialisationInProgress.equal(&false)).implies(|| self.VehicleTryKeepTimeGap.equal(&true))) && ((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODveryclose) && self.ObstacleStatusJustChanged.equal(&false)) && self.CCInitialisationInProgress.equal(&false)).implies(|| self.VehicleTryKeepTimeGap.equal(&true))) && (((self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos) && self.ObstacleDistance.unequal(&/*enum_call*/ODset::ODveryclose)) && self.ObstacleStatusJustChanged.equal(&false)) && self.CCInitialisationInProgress.equal(&false)).implies(|| self.VehicleTryKeepSpeed.equal(&true))) {
+ self.CruiseSpeedChangeInProgress = true;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn CruiseOff(&mut self) -> () {
+ //select
+ if self.CruiseActive.equal(&true) {
+ self.CruiseActive = false;
+ self.VehicleCanKeepSpeed = false;
+ self.VehicleTryKeepSpeed = false;
+ self.VehicleAtCruiseSpeed = false;
+ self.VehicleTryKeepTimeGap = false;
+ self.CruiseSpeedAtMax = false;
+ self.ObstacleDistance = /*enum_call*/ODset::ODnone;
+ self.NumberOfSetCruise = 0;
+ self.ObstacleStatusJustChanged = false;
+ self.CCInitialisationInProgress = false;
+ self.CruiseSpeedChangeInProgress = false;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn ExternalForcesBecomesExtreme(&mut self) -> () {
+ //select
+ if self.VehicleCanKeepSpeed.equal(&true) {
+ self.VehicleCanKeepSpeed = false;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn ExternalForcesBecomesNormal(&mut self) -> () {
+ //select
+ if (self.CruiseActive.equal(&true) && self.VehicleCanKeepSpeed.equal(&false)) {
+ self.VehicleCanKeepSpeed = true;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn VehicleLeavesCruiseSpeed(&mut self) -> () {
+ //select
+ if ((self.VehicleAtCruiseSpeed.equal(&true) && (self.VehicleCanKeepSpeed.equal(&false) && self.VehicleTryKeepSpeed.equal(&true))) || self.VehicleTryKeepSpeed.equal(&false)) {
+ self.VehicleAtCruiseSpeed = false;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn VehicleReachesCruiseSpeed(&mut self) -> () {
+ //select
+ if ((self.CruiseActive.equal(&true) && self.VehicleAtCruiseSpeed.equal(&false)) && self.SpeedAboveMax.equal(&false)) {
+ self.VehicleAtCruiseSpeed = true;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn VehicleExceedsMaxCruiseSpeed(&mut self) -> () {
+ //select
+ if (self.SpeedAboveMax.equal(&false) && ((self.CruiseActive.equal(&false) || self.VehicleCanKeepSpeed.equal(&false)) || ((self.ObstacleStatusJustChanged.equal(&false) && self.CCInitialisationInProgress.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)))) {
+ self.SpeedAboveMax = true;
+ self.VehicleAtCruiseSpeed = false;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn VehicleFallsBelowMaxCruiseSpeed(&mut self) -> () {
+ //select
+ if self.SpeedAboveMax.equal(&true) {
+ self.SpeedAboveMax = false;
+ //if
+ if (self.CruiseActive.equal(&true) && self.CruiseSpeedAtMax.equal(&true)) {
+ self.VehicleAtCruiseSpeed = true;
+ }
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn ObstacleDistanceBecomesVeryClose(&mut self) -> () {
+ //select
+ if (self.ObstacleDistance.equal(&/*enum_call*/ODset::ODclose) && self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSneg)) {
+ self.ObstacleDistance = /*enum_call*/ODset::ODveryclose;
+ self.ObstacleStatusJustChanged = true;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn ObstacleDistanceBecomesClose(&mut self) -> () {
+ //select
+ if ((self.ObstaclePresent.equal(&true) && self.CruiseActive.equal(&true)) && ((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODveryclose) && self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos)) || (self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone) && self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSneg)))) {
+ self.ObstacleDistance = /*enum_call*/ODset::ODclose;
+ self.ObstacleStatusJustChanged = true;
+ //if
+ if self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos) {
+ self.VehicleTryKeepTimeGap = false;
+ }
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn ObstacleDistanceBecomesBig(&mut self) -> () {
+ //select
+ if (self.ObstacleDistance.equal(&/*enum_call*/ODset::ODclose) && self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos)) {
+ self.ObstacleStatusJustChanged = true;
+ self.ObstacleDistance = /*enum_call*/ODset::ODnone;
+ self.VehicleTryKeepTimeGap = false;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn ObstacleStartsTravelFaster(&mut self) -> () {
+ //select
+ if (self.ObstaclePresent.equal(&true) && self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSequal)) {
+ self.ObstacleRelativeSpeed = /*enum_call*/RSset::RSpos;
+ //if
+ if self.CruiseActive.equal(&true) {
+ self.ObstacleStatusJustChanged = true;
+ }
+ //if
+ if self.ObstacleDistance.unequal(&/*enum_call*/ODset::ODveryclose) {
+ self.VehicleTryKeepTimeGap = false;
+ }
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn ObstacleStopsTravelFaster(&mut self) -> () {
+ //select
+ if self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos) {
+ self.ObstacleRelativeSpeed = /*enum_call*/RSset::RSequal;
+ //if
+ if self.CruiseActive.equal(&true) {
+ self.ObstacleStatusJustChanged = true;
+ }
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn ObstacleStartsTravelSlower(&mut self) -> () {
+ //select
+ if self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSequal) {
+ self.ObstacleRelativeSpeed = /*enum_call*/RSset::RSneg;
+ //if
+ if self.CruiseActive.equal(&true) {
+ self.ObstacleStatusJustChanged = true;
+ }
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn ObstacleStopsTravelSlower(&mut self) -> () {
+ //select
+ if self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSneg) {
+ self.ObstacleRelativeSpeed = /*enum_call*/RSset::RSequal;
+ //if
+ if self.CruiseActive.equal(&true) {
+ self.ObstacleStatusJustChanged = true;
+ }
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn ObstacleAppearsWhenCruiseActive(&mut self, mut ors: RSset, mut od: ODset) -> () {
+ //pre_assert
+ self.ObstaclePresent = true;
+ self.ObstacleStatusJustChanged = true;
+ self.ObstacleRelativeSpeed = ors;
+ self.ObstacleDistance = od;
+
+ }
+
+ pub fn ObstacleAppearsWhenCruiseInactive(&mut self, mut ors: RSset) -> () {
+ //pre_assert
+ self.ObstaclePresent = true;
+ self.ObstacleRelativeSpeed = ors;
+ self.ObstacleDistance = /*enum_call*/ODset::ODnone;
+
+ }
+
+ pub fn ObstacleDisappears(&mut self) -> () {
+ //select
+ if self.ObstaclePresent.equal(&true) {
+ self.ObstaclePresent = false;
+ self.ObstacleRelativeSpeed = /*enum_call*/RSset::RSnone;
+ //if
+ if self.CruiseActive.equal(&true) {
+ self.ObstacleStatusJustChanged = true;
+ }
+ self.ObstacleDistance = /*enum_call*/ODset::ODnone;
+ self.VehicleTryKeepTimeGap = false;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn VehicleManageObstacle(&mut self, mut vtks: BBoolean, mut vtktg: BBoolean) -> () {
+ //select
+ if (((((((((((BOOL.elementOf(&vtks) && BOOL.elementOf(&vtktg)) && (((vtks.equal(&true) || vtktg.equal(&true)) || self.CCInitialisationInProgress.equal(&true)) || self.CruiseSpeedChangeInProgress.equal(&true))) && self.ObstaclePresent.equal(&false).implies(|| vtktg.equal(&false))) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone).implies(|| vtks.equal(&true))) && (((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODclose) && self.ObstacleRelativeSpeed.unequal(&/*enum_call*/RSset::RSpos)) && self.CCInitialisationInProgress.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| vtktg.equal(&true))) && ((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODveryclose) && self.CCInitialisationInProgress.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| vtktg.equal(&true))) && (((self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos) && self.ObstacleDistance.unequal(&/*enum_call*/ODset::ODveryclose)) && self.CCInitialisationInProgress.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| vtks.equal(&true))) && (self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSequal) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone)).implies(|| vtktg.equal(&false))) && (self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSneg) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone)).implies(|| vtktg.equal(&false))) && (self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos) && self.ObstacleDistance.unequal(&/*enum_call*/ODset::ODveryclose)).implies(|| vtktg.equal(&false))) && self.ObstacleStatusJustChanged.equal(&true)) {
+ self.VehicleTryKeepTimeGap = vtktg;
+ self.VehicleTryKeepSpeed = vtks;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn ObstacleBecomesOld(&mut self) -> () {
+ //select
+ if (((((self.ObstacleStatusJustChanged.equal(&true) && (((self.VehicleTryKeepSpeed.equal(&true) || self.VehicleTryKeepTimeGap.equal(&true)) || self.CCInitialisationInProgress.equal(&true)) || self.CruiseSpeedChangeInProgress.equal(&true))) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone).implies(|| self.VehicleTryKeepSpeed.equal(&true))) && (((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODclose) && self.ObstacleRelativeSpeed.unequal(&/*enum_call*/RSset::RSpos)) && self.CCInitialisationInProgress.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| self.VehicleTryKeepTimeGap.equal(&true))) && ((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODveryclose) && self.CCInitialisationInProgress.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| self.VehicleTryKeepTimeGap.equal(&true))) && (((self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos) && self.ObstacleDistance.unequal(&/*enum_call*/ODset::ODveryclose)) && self.CCInitialisationInProgress.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| self.VehicleTryKeepSpeed.equal(&true))) {
+ self.ObstacleStatusJustChanged = false;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn _tr_CruiseBecomesNotAllowed(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_CruiseBecomesNotAllowed.is_none() {
+ let mut __tmp__val__ = self.CruiseAllowed.equal(&true);
+ self._tr_cache_CruiseBecomesNotAllowed = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_CruiseBecomesNotAllowed.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_CruiseBecomesAllowed(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_CruiseBecomesAllowed.is_none() {
+ let mut __tmp__val__ = self.CruiseAllowed.equal(&false);
+ self._tr_cache_CruiseBecomesAllowed = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_CruiseBecomesAllowed.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_SetCruiseSpeed(&mut self, is_caching: bool) -> HashSet<(BBoolean, BBoolean)> {
+ //transition
+ if !is_caching || self._tr_cache_SetCruiseSpeed.is_none() {
+ let mut _ic_set_2: HashSet<(BBoolean, BBoolean)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_vcks_1 in BOOL.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_csam_1 in BOOL.clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if self.CruiseAllowed.equal(&true) {
+ _ic_set_2.insert((_ic_vcks_1.clone(), _ic_csam_1.clone()));
+ }
+
+ }
+ }
+ self._tr_cache_SetCruiseSpeed = Option::Some(_ic_set_2.clone());
+ return _ic_set_2;
+ } else {
+ return self._tr_cache_SetCruiseSpeed.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_CCInitialisationFinished(&mut self, is_caching: bool) -> HashSet<(BBoolean, BBoolean)> {
+ //transition
+ if !is_caching || self._tr_cache_CCInitialisationFinished.is_none() {
+ let mut _ic_set_3: HashSet<(BBoolean, BBoolean)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_vtks_1 in BOOL.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_vtktg_1 in BOOL.clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if ((((((((((((_ic_vtks_1.equal(&true) || _ic_vtktg_1.equal(&true)) || self.ObstacleStatusJustChanged.equal(&true)) || self.CruiseSpeedChangeInProgress.equal(&true)) && self.ObstaclePresent.equal(&false).implies(|| _ic_vtktg_1.equal(&false))) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone).implies(|| _ic_vtks_1.equal(&true))) && (((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODclose) && self.ObstacleRelativeSpeed.unequal(&/*enum_call*/RSset::RSpos)) && self.ObstacleStatusJustChanged.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| _ic_vtktg_1.equal(&true))) && ((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODveryclose) && self.ObstacleStatusJustChanged.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| _ic_vtktg_1.equal(&true))) && (((self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos) && self.ObstacleDistance.unequal(&/*enum_call*/ODset::ODveryclose)) && self.ObstacleStatusJustChanged.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| _ic_vtks_1.equal(&true))) && (self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSequal) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone)).implies(|| _ic_vtktg_1.equal(&false))) && (self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSneg) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone)).implies(|| _ic_vtktg_1.equal(&false))) && (self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos) && self.ObstacleDistance.unequal(&/*enum_call*/ODset::ODveryclose)).implies(|| _ic_vtktg_1.equal(&false))) && self.CCInitialisationInProgress.equal(&true)) {
+ _ic_set_3.insert((_ic_vtks_1.clone(), _ic_vtktg_1.clone()));
+ }
+
+ }
+ }
+ self._tr_cache_CCInitialisationFinished = Option::Some(_ic_set_3.clone());
+ return _ic_set_3;
+ } else {
+ return self._tr_cache_CCInitialisationFinished.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_CCInitialisationDelayFinished(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_CCInitialisationDelayFinished.is_none() {
+ let mut __tmp__val__ = (((((self.CCInitialisationInProgress.equal(&true) && (((self.VehicleTryKeepSpeed.equal(&true) || self.VehicleTryKeepTimeGap.equal(&true)) || self.ObstacleStatusJustChanged.equal(&true)) || self.CruiseSpeedChangeInProgress.equal(&true))) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone).implies(|| self.VehicleTryKeepSpeed.equal(&true))) && (((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODclose) && self.ObstacleRelativeSpeed.unequal(&/*enum_call*/RSset::RSpos)) && self.ObstacleStatusJustChanged.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| self.VehicleTryKeepTimeGap.equal(&true))) && ((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODveryclose) && self.ObstacleStatusJustChanged.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| self.VehicleTryKeepTimeGap.equal(&true))) && (((self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos) && self.ObstacleDistance.unequal(&/*enum_call*/ODset::ODveryclose)) && self.ObstacleStatusJustChanged.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| self.VehicleTryKeepSpeed.equal(&true)));
+ self._tr_cache_CCInitialisationDelayFinished = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_CCInitialisationDelayFinished.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_CruiseSpeedChangeFinished(&mut self, is_caching: bool) -> HashSet<(BBoolean, BBoolean)> {
+ //transition
+ if !is_caching || self._tr_cache_CruiseSpeedChangeFinished.is_none() {
+ let mut _ic_set_5: HashSet<(BBoolean, BBoolean)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_vtks_1 in BOOL.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_vtktg_1 in BOOL.clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if ((((((((((((_ic_vtks_1.equal(&true) || _ic_vtktg_1.equal(&true)) || self.ObstacleStatusJustChanged.equal(&true)) || self.CCInitialisationInProgress.equal(&true)) && self.ObstaclePresent.equal(&false).implies(|| _ic_vtktg_1.equal(&false))) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone).implies(|| _ic_vtks_1.equal(&true))) && (((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODclose) && self.ObstacleRelativeSpeed.unequal(&/*enum_call*/RSset::RSpos)) && self.ObstacleStatusJustChanged.equal(&false)) && self.CCInitialisationInProgress.equal(&false)).implies(|| _ic_vtktg_1.equal(&true))) && ((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODveryclose) && self.ObstacleStatusJustChanged.equal(&false)) && self.CCInitialisationInProgress.equal(&false)).implies(|| _ic_vtktg_1.equal(&true))) && (((self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos) && self.ObstacleDistance.unequal(&/*enum_call*/ODset::ODveryclose)) && self.ObstacleStatusJustChanged.equal(&false)) && self.CCInitialisationInProgress.equal(&false)).implies(|| _ic_vtks_1.equal(&true))) && (self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSequal) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone)).implies(|| _ic_vtktg_1.equal(&false))) && (self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSneg) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone)).implies(|| _ic_vtktg_1.equal(&false))) && (self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos) && self.ObstacleDistance.unequal(&/*enum_call*/ODset::ODveryclose)).implies(|| _ic_vtktg_1.equal(&false))) && self.CruiseSpeedChangeInProgress.equal(&true)) {
+ _ic_set_5.insert((_ic_vtks_1.clone(), _ic_vtktg_1.clone()));
+ }
+
+ }
+ }
+ self._tr_cache_CruiseSpeedChangeFinished = Option::Some(_ic_set_5.clone());
+ return _ic_set_5;
+ } else {
+ return self._tr_cache_CruiseSpeedChangeFinished.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_CruiseSpeedChangeDelayFinished(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_CruiseSpeedChangeDelayFinished.is_none() {
+ let mut __tmp__val__ = (((((self.CruiseSpeedChangeInProgress.equal(&true) && (((self.VehicleTryKeepSpeed.equal(&true) || self.VehicleTryKeepTimeGap.equal(&true)) || self.ObstacleStatusJustChanged.equal(&true)) || self.CCInitialisationInProgress.equal(&true))) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone).implies(|| self.VehicleTryKeepSpeed.equal(&true))) && (((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODclose) && self.ObstacleRelativeSpeed.unequal(&/*enum_call*/RSset::RSpos)) && self.ObstacleStatusJustChanged.equal(&false)) && self.CCInitialisationInProgress.equal(&false)).implies(|| self.VehicleTryKeepTimeGap.equal(&true))) && ((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODveryclose) && self.ObstacleStatusJustChanged.equal(&false)) && self.CCInitialisationInProgress.equal(&false)).implies(|| self.VehicleTryKeepTimeGap.equal(&true))) && (((self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos) && self.ObstacleDistance.unequal(&/*enum_call*/ODset::ODveryclose)) && self.ObstacleStatusJustChanged.equal(&false)) && self.CCInitialisationInProgress.equal(&false)).implies(|| self.VehicleTryKeepSpeed.equal(&true)));
+ self._tr_cache_CruiseSpeedChangeDelayFinished = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_CruiseSpeedChangeDelayFinished.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_CruiseOff(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_CruiseOff.is_none() {
+ let mut __tmp__val__ = self.CruiseActive.equal(&true);
+ self._tr_cache_CruiseOff = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_CruiseOff.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_ExternalForcesBecomesExtreme(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_ExternalForcesBecomesExtreme.is_none() {
+ let mut __tmp__val__ = self.VehicleCanKeepSpeed.equal(&true);
+ self._tr_cache_ExternalForcesBecomesExtreme = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_ExternalForcesBecomesExtreme.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_ExternalForcesBecomesNormal(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_ExternalForcesBecomesNormal.is_none() {
+ let mut __tmp__val__ = (self.CruiseActive.equal(&true) && self.VehicleCanKeepSpeed.equal(&false));
+ self._tr_cache_ExternalForcesBecomesNormal = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_ExternalForcesBecomesNormal.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_VehicleLeavesCruiseSpeed(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_VehicleLeavesCruiseSpeed.is_none() {
+ let mut __tmp__val__ = ((self.VehicleAtCruiseSpeed.equal(&true) && (self.VehicleCanKeepSpeed.equal(&false) && self.VehicleTryKeepSpeed.equal(&true))) || self.VehicleTryKeepSpeed.equal(&false));
+ self._tr_cache_VehicleLeavesCruiseSpeed = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_VehicleLeavesCruiseSpeed.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_VehicleReachesCruiseSpeed(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_VehicleReachesCruiseSpeed.is_none() {
+ let mut __tmp__val__ = ((self.CruiseActive.equal(&true) && self.VehicleAtCruiseSpeed.equal(&false)) && self.SpeedAboveMax.equal(&false));
+ self._tr_cache_VehicleReachesCruiseSpeed = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_VehicleReachesCruiseSpeed.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_VehicleExceedsMaxCruiseSpeed(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_VehicleExceedsMaxCruiseSpeed.is_none() {
+ let mut __tmp__val__ = (self.SpeedAboveMax.equal(&false) && ((self.CruiseActive.equal(&false) || self.VehicleCanKeepSpeed.equal(&false)) || ((self.ObstacleStatusJustChanged.equal(&false) && self.CCInitialisationInProgress.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false))));
+ self._tr_cache_VehicleExceedsMaxCruiseSpeed = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_VehicleExceedsMaxCruiseSpeed.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_VehicleFallsBelowMaxCruiseSpeed(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_VehicleFallsBelowMaxCruiseSpeed.is_none() {
+ let mut __tmp__val__ = self.SpeedAboveMax.equal(&true);
+ self._tr_cache_VehicleFallsBelowMaxCruiseSpeed = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_VehicleFallsBelowMaxCruiseSpeed.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_ObstacleDistanceBecomesVeryClose(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_ObstacleDistanceBecomesVeryClose.is_none() {
+ let mut __tmp__val__ = (self.ObstacleDistance.equal(&/*enum_call*/ODset::ODclose) && self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSneg));
+ self._tr_cache_ObstacleDistanceBecomesVeryClose = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_ObstacleDistanceBecomesVeryClose.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_ObstacleDistanceBecomesClose(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_ObstacleDistanceBecomesClose.is_none() {
+ let mut __tmp__val__ = ((self.ObstaclePresent.equal(&true) && self.CruiseActive.equal(&true)) && ((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODveryclose) && self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos)) || (self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone) && self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSneg))));
+ self._tr_cache_ObstacleDistanceBecomesClose = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_ObstacleDistanceBecomesClose.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_ObstacleDistanceBecomesBig(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_ObstacleDistanceBecomesBig.is_none() {
+ let mut __tmp__val__ = (self.ObstacleDistance.equal(&/*enum_call*/ODset::ODclose) && self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos));
+ self._tr_cache_ObstacleDistanceBecomesBig = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_ObstacleDistanceBecomesBig.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_ObstacleStartsTravelFaster(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_ObstacleStartsTravelFaster.is_none() {
+ let mut __tmp__val__ = (self.ObstaclePresent.equal(&true) && self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSequal));
+ self._tr_cache_ObstacleStartsTravelFaster = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_ObstacleStartsTravelFaster.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_ObstacleStopsTravelFaster(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_ObstacleStopsTravelFaster.is_none() {
+ let mut __tmp__val__ = self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos);
+ self._tr_cache_ObstacleStopsTravelFaster = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_ObstacleStopsTravelFaster.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_ObstacleStartsTravelSlower(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_ObstacleStartsTravelSlower.is_none() {
+ let mut __tmp__val__ = self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSequal);
+ self._tr_cache_ObstacleStartsTravelSlower = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_ObstacleStartsTravelSlower.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_ObstacleStopsTravelSlower(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_ObstacleStopsTravelSlower.is_none() {
+ let mut __tmp__val__ = self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSneg);
+ self._tr_cache_ObstacleStopsTravelSlower = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_ObstacleStopsTravelSlower.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_ObstacleAppearsWhenCruiseActive(&mut self, is_caching: bool) -> HashSet<(RSset, ODset)> {
+ //transition
+ if !is_caching || self._tr_cache_ObstacleAppearsWhenCruiseActive.is_none() {
+ let mut _ic_set_21: HashSet<(RSset, ODset)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_ors_1 in self._RSset.difference(&bset![RSset, /*enum_call*/RSset::RSnone]).clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_od_1 in self._ODset.difference(&bset![ODset, /*enum_call*/ODset::ODnone]).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if (self.ObstaclePresent.equal(&false) && self.CruiseActive.equal(&true)) {
+ _ic_set_21.insert((_ic_ors_1.clone(), _ic_od_1.clone()));
+ }
+
+ }
+ }
+ self._tr_cache_ObstacleAppearsWhenCruiseActive = Option::Some(_ic_set_21.clone());
+ return _ic_set_21;
+ } else {
+ return self._tr_cache_ObstacleAppearsWhenCruiseActive.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_ObstacleAppearsWhenCruiseInactive(&mut self, is_caching: bool) -> HashSet<RSset> {
+ //transition
+ if !is_caching || self._tr_cache_ObstacleAppearsWhenCruiseInactive.is_none() {
+ let mut _ic_set_22: HashSet<RSset> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_ors_1 in self._RSset.difference(&bset![RSset, /*enum_call*/RSset::RSnone]).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if (self.ObstaclePresent.equal(&false) && self.CruiseActive.equal(&false)) {
+ _ic_set_22.insert(_ic_ors_1);
+ }
+
+ }
+ self._tr_cache_ObstacleAppearsWhenCruiseInactive = Option::Some(_ic_set_22.clone());
+ return _ic_set_22;
+ } else {
+ return self._tr_cache_ObstacleAppearsWhenCruiseInactive.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_ObstacleDisappears(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_ObstacleDisappears.is_none() {
+ let mut __tmp__val__ = self.ObstaclePresent.equal(&true);
+ self._tr_cache_ObstacleDisappears = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_ObstacleDisappears.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_VehicleManageObstacle(&mut self, is_caching: bool) -> HashSet<(BBoolean, BBoolean)> {
+ //transition
+ if !is_caching || self._tr_cache_VehicleManageObstacle.is_none() {
+ let mut _ic_set_24: HashSet<(BBoolean, BBoolean)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_vtks_1 in BOOL.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_vtktg_1 in BOOL.clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if ((((((((((((_ic_vtks_1.equal(&true) || _ic_vtktg_1.equal(&true)) || self.CCInitialisationInProgress.equal(&true)) || self.CruiseSpeedChangeInProgress.equal(&true)) && self.ObstaclePresent.equal(&false).implies(|| _ic_vtktg_1.equal(&false))) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone).implies(|| _ic_vtks_1.equal(&true))) && (((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODclose) && self.ObstacleRelativeSpeed.unequal(&/*enum_call*/RSset::RSpos)) && self.CCInitialisationInProgress.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| _ic_vtktg_1.equal(&true))) && ((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODveryclose) && self.CCInitialisationInProgress.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| _ic_vtktg_1.equal(&true))) && (((self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos) && self.ObstacleDistance.unequal(&/*enum_call*/ODset::ODveryclose)) && self.CCInitialisationInProgress.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| _ic_vtks_1.equal(&true))) && (self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSequal) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone)).implies(|| _ic_vtktg_1.equal(&false))) && (self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSneg) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone)).implies(|| _ic_vtktg_1.equal(&false))) && (self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos) && self.ObstacleDistance.unequal(&/*enum_call*/ODset::ODveryclose)).implies(|| _ic_vtktg_1.equal(&false))) && self.ObstacleStatusJustChanged.equal(&true)) {
+ _ic_set_24.insert((_ic_vtks_1.clone(), _ic_vtktg_1.clone()));
+ }
+
+ }
+ }
+ self._tr_cache_VehicleManageObstacle = Option::Some(_ic_set_24.clone());
+ return _ic_set_24;
+ } else {
+ return self._tr_cache_VehicleManageObstacle.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_ObstacleBecomesOld(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_ObstacleBecomesOld.is_none() {
+ let mut __tmp__val__ = (((((self.ObstacleStatusJustChanged.equal(&true) && (((self.VehicleTryKeepSpeed.equal(&true) || self.VehicleTryKeepTimeGap.equal(&true)) || self.CCInitialisationInProgress.equal(&true)) || self.CruiseSpeedChangeInProgress.equal(&true))) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone).implies(|| self.VehicleTryKeepSpeed.equal(&true))) && (((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODclose) && self.ObstacleRelativeSpeed.unequal(&/*enum_call*/RSset::RSpos)) && self.CCInitialisationInProgress.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| self.VehicleTryKeepTimeGap.equal(&true))) && ((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODveryclose) && self.CCInitialisationInProgress.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| self.VehicleTryKeepTimeGap.equal(&true))) && (((self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos) && self.ObstacleDistance.unequal(&/*enum_call*/ODset::ODveryclose)) && self.CCInitialisationInProgress.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).implies(|| self.VehicleTryKeepSpeed.equal(&true)));
+ self._tr_cache_ObstacleBecomesOld = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_ObstacleBecomesOld.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _check_inv_1(&self) -> bool {
+ //invariant
+ return BOOL.elementOf(&self.CruiseAllowed);
+ }
+
+ pub fn _check_inv_2(&self) -> bool {
+ //invariant
+ return BOOL.elementOf(&self.CruiseActive);
+ }
+
+ pub fn _check_inv_3(&self) -> bool {
+ //invariant
+ return BOOL.elementOf(&self.VehicleAtCruiseSpeed);
+ }
+
+ pub fn _check_inv_4(&self) -> bool {
+ //invariant
+ return BOOL.elementOf(&self.VehicleCanKeepSpeed);
+ }
+
+ pub fn _check_inv_5(&self) -> bool {
+ //invariant
+ return BOOL.elementOf(&self.VehicleTryKeepSpeed);
+ }
+
+ pub fn _check_inv_6(&self) -> bool {
+ //invariant
+ return BOOL.elementOf(&self.SpeedAboveMax);
+ }
+
+ pub fn _check_inv_7(&self) -> bool {
+ //invariant
+ return BOOL.elementOf(&self.VehicleTryKeepTimeGap);
+ }
+
+ pub fn _check_inv_8(&self) -> bool {
+ //invariant
+ return BOOL.elementOf(&self.CruiseSpeedAtMax);
+ }
+
+ pub fn _check_inv_9(&self) -> bool {
+ //invariant
+ return self.NumberOfSetCruise.isNatural();
+ }
+
+ pub fn _check_inv_10(&self) -> bool {
+ //invariant
+ return set_BInteger::interval(&0, &1).elementOf(&self.NumberOfSetCruise);
+ }
+
+ pub fn _check_inv_11(&self) -> bool {
+ //invariant
+ return BOOL.elementOf(&self.ObstaclePresent);
+ }
+
+ pub fn _check_inv_12(&self) -> bool {
+ //invariant
+ return self._ODset.elementOf(&self.ObstacleDistance);
+ }
+
+ pub fn _check_inv_13(&self) -> bool {
+ //invariant
+ return self._RSset.elementOf(&self.ObstacleRelativeSpeed);
+ }
+
+ pub fn _check_inv_14(&self) -> bool {
+ //invariant
+ return BOOL.elementOf(&self.ObstacleStatusJustChanged);
+ }
+
+ pub fn _check_inv_15(&self) -> bool {
+ //invariant
+ return BOOL.elementOf(&self.CCInitialisationInProgress);
+ }
+
+ pub fn _check_inv_16(&self) -> bool {
+ //invariant
+ return BOOL.elementOf(&self.CruiseSpeedChangeInProgress);
+ }
+
+ pub fn _check_inv_17(&self) -> bool {
+ //invariant
+ return self.CruiseActive.equal(&false).implies(|| self.VehicleAtCruiseSpeed.equal(&false));
+ }
+
+ pub fn _check_inv_18(&self) -> bool {
+ //invariant
+ return self.CruiseActive.equal(&false).implies(|| self.VehicleCanKeepSpeed.equal(&false));
+ }
+
+ pub fn _check_inv_19(&self) -> bool {
+ //invariant
+ return self.CruiseActive.equal(&false).implies(|| self.VehicleTryKeepSpeed.equal(&false));
+ }
+
+ pub fn _check_inv_20(&self) -> bool {
+ //invariant
+ return self.NumberOfSetCruise.equal(&0).equivalent(&self.CruiseActive.equal(&false));
+ }
+
+ pub fn _check_inv_21(&self) -> bool {
+ //invariant
+ return self.CruiseActive.equal(&false).implies(|| self.VehicleTryKeepTimeGap.equal(&false));
+ }
+
+ pub fn _check_inv_22(&self) -> bool {
+ //invariant
+ return self.CruiseActive.equal(&false).implies(|| self.CruiseSpeedAtMax.equal(&false));
+ }
+
+ pub fn _check_inv_23(&self) -> bool {
+ //invariant
+ return self.CruiseActive.equal(&false).implies(|| self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone));
+ }
+
+ pub fn _check_inv_24(&self) -> bool {
+ //invariant
+ return self.CruiseActive.equal(&false).implies(|| self.ObstacleStatusJustChanged.equal(&false));
+ }
+
+ pub fn _check_inv_25(&self) -> bool {
+ //invariant
+ return self.CruiseActive.equal(&false).implies(|| self.CCInitialisationInProgress.equal(&false));
+ }
+
+ pub fn _check_inv_26(&self) -> bool {
+ //invariant
+ return self.CruiseActive.equal(&false).implies(|| self.CruiseSpeedChangeInProgress.equal(&false));
+ }
+
+ pub fn _check_inv_27(&self) -> bool {
+ //invariant
+ return self.ObstaclePresent.equal(&false).implies(|| self.VehicleTryKeepTimeGap.equal(&false));
+ }
+
+ pub fn _check_inv_28(&self) -> bool {
+ //invariant
+ return self.ObstaclePresent.equal(&false).implies(|| self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone));
+ }
+
+ pub fn _check_inv_29(&self) -> bool {
+ //invariant
+ return self.ObstaclePresent.equal(&false).equivalent(&self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSnone));
+ }
+
+ pub fn _check_inv_30(&self) -> bool {
+ //invariant
+ return (self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSequal) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone)).implies(|| self.VehicleTryKeepTimeGap.equal(&false));
+ }
+
+ pub fn _check_inv_31(&self) -> bool {
+ //invariant
+ return (self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSneg) && self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone)).implies(|| self.VehicleTryKeepTimeGap.equal(&false));
+ }
+
+ pub fn _check_inv_32(&self) -> bool {
+ //invariant
+ return (self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos) && self.ObstacleDistance.unequal(&/*enum_call*/ODset::ODveryclose)).implies(|| self.VehicleTryKeepTimeGap.equal(&false));
+ }
+
+ pub fn _check_inv_33(&self) -> bool {
+ //invariant
+ return self.CruiseAllowed.equal(&false).implies(|| self.CruiseActive.equal(&false));
+ }
+
+ pub fn _check_inv_34(&self) -> bool {
+ //invariant
+ return self.SpeedAboveMax.equal(&true).implies(|| self.VehicleAtCruiseSpeed.equal(&false));
+ }
+
+ pub fn _check_inv_35(&self) -> bool {
+ //invariant
+ return self.CruiseActive.equal(&true).implies(|| ((self.VehicleTryKeepSpeed.equal(&true) || self.VehicleTryKeepTimeGap.equal(&true)) || ((self.ObstacleStatusJustChanged.equal(&false) && self.CCInitialisationInProgress.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false)).not()));
+ }
+
+ pub fn _check_inv_36(&self) -> bool {
+ //invariant
+ return ((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODnone) && self.CruiseActive.equal(&true)) && ((self.ObstacleStatusJustChanged.equal(&false) && self.CCInitialisationInProgress.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false))).implies(|| self.VehicleTryKeepSpeed.equal(&true));
+ }
+
+ pub fn _check_inv_37(&self) -> bool {
+ //invariant
+ return ((self.ObstacleDistance.equal(&/*enum_call*/ODset::ODclose) && self.ObstacleRelativeSpeed.unequal(&/*enum_call*/RSset::RSpos)) && ((self.ObstacleStatusJustChanged.equal(&false) && self.CCInitialisationInProgress.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false))).implies(|| self.VehicleTryKeepTimeGap.equal(&true));
+ }
+
+ pub fn _check_inv_38(&self) -> bool {
+ //invariant
+ return (self.ObstacleDistance.equal(&/*enum_call*/ODset::ODveryclose) && ((self.ObstacleStatusJustChanged.equal(&false) && self.CCInitialisationInProgress.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false))).implies(|| self.VehicleTryKeepTimeGap.equal(&true));
+ }
+
+ pub fn _check_inv_39(&self) -> bool {
+ //invariant
+ return (((self.ObstacleRelativeSpeed.equal(&/*enum_call*/RSset::RSpos) && self.ObstacleDistance.unequal(&/*enum_call*/ODset::ODveryclose)) && self.CruiseActive.equal(&true)) && ((self.ObstacleStatusJustChanged.equal(&false) && self.CCInitialisationInProgress.equal(&false)) && self.CruiseSpeedChangeInProgress.equal(&false))).implies(|| self.VehicleTryKeepSpeed.equal(&true));
+ }
+
+ fn invalidate_caches(&mut self, to_invalidate: Vec<&'static str>) {
+ //calling the given functions without caching will recalculate them and cache them afterwards
+ for trans in to_invalidate {
+ match trans {
+ "_tr_CruiseBecomesNotAllowed" => {self._tr_CruiseBecomesNotAllowed(false);},
+ "_tr_CruiseBecomesAllowed" => {self._tr_CruiseBecomesAllowed(false);},
+ "_tr_SetCruiseSpeed" => {self._tr_SetCruiseSpeed(false);},
+ "_tr_CCInitialisationFinished" => {self._tr_CCInitialisationFinished(false);},
+ "_tr_CCInitialisationDelayFinished" => {self._tr_CCInitialisationDelayFinished(false);},
+ "_tr_CruiseSpeedChangeFinished" => {self._tr_CruiseSpeedChangeFinished(false);},
+ "_tr_CruiseSpeedChangeDelayFinished" => {self._tr_CruiseSpeedChangeDelayFinished(false);},
+ "_tr_CruiseOff" => {self._tr_CruiseOff(false);},
+ "_tr_ExternalForcesBecomesExtreme" => {self._tr_ExternalForcesBecomesExtreme(false);},
+ "_tr_ExternalForcesBecomesNormal" => {self._tr_ExternalForcesBecomesNormal(false);},
+ "_tr_VehicleLeavesCruiseSpeed" => {self._tr_VehicleLeavesCruiseSpeed(false);},
+ "_tr_VehicleReachesCruiseSpeed" => {self._tr_VehicleReachesCruiseSpeed(false);},
+ "_tr_VehicleExceedsMaxCruiseSpeed" => {self._tr_VehicleExceedsMaxCruiseSpeed(false);},
+ "_tr_VehicleFallsBelowMaxCruiseSpeed" => {self._tr_VehicleFallsBelowMaxCruiseSpeed(false);},
+ "_tr_ObstacleDistanceBecomesVeryClose" => {self._tr_ObstacleDistanceBecomesVeryClose(false);},
+ "_tr_ObstacleDistanceBecomesClose" => {self._tr_ObstacleDistanceBecomesClose(false);},
+ "_tr_ObstacleDistanceBecomesBig" => {self._tr_ObstacleDistanceBecomesBig(false);},
+ "_tr_ObstacleStartsTravelFaster" => {self._tr_ObstacleStartsTravelFaster(false);},
+ "_tr_ObstacleStopsTravelFaster" => {self._tr_ObstacleStopsTravelFaster(false);},
+ "_tr_ObstacleStartsTravelSlower" => {self._tr_ObstacleStartsTravelSlower(false);},
+ "_tr_ObstacleStopsTravelSlower" => {self._tr_ObstacleStopsTravelSlower(false);},
+ "_tr_ObstacleAppearsWhenCruiseActive" => {self._tr_ObstacleAppearsWhenCruiseActive(false);},
+ "_tr_ObstacleAppearsWhenCruiseInactive" => {self._tr_ObstacleAppearsWhenCruiseInactive(false);},
+ "_tr_ObstacleDisappears" => {self._tr_ObstacleDisappears(false);},
+ "_tr_VehicleManageObstacle" => {self._tr_VehicleManageObstacle(false);},
+ "_tr_ObstacleBecomesOld" => {self._tr_ObstacleBecomesOld(false);},
+ _ => {},
+ }
+ }
+ }
+
+ //model_check_next_states
+ fn generateNextStates(state: &mut Cruise_finite1_deterministic_MC,
+ isCaching: bool,
+ transitions: Arc<AtomicU64>) -> HashSet<(Cruise_finite1_deterministic_MC, &'static str)> {
+ let mut result = HashSet::<(Cruise_finite1_deterministic_MC, &'static str)>::new();
+ let mut evaluated_transitions: u64 = 0;
+ //model_check_transition
+ if state._tr_CruiseBecomesNotAllowed(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.CruiseBecomesNotAllowed();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("CruiseBecomesNotAllowed")); }
+ result.insert((copiedState, "CruiseBecomesNotAllowed"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_CruiseBecomesAllowed(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.CruiseBecomesAllowed();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("CruiseBecomesAllowed")); }
+ result.insert((copiedState, "CruiseBecomesAllowed"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_3 = state._tr_SetCruiseSpeed(isCaching);
+ for param in _trid_3.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.SetCruiseSpeed(_tmp_2, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("SetCruiseSpeed")); }
+ result.insert((copiedState, "SetCruiseSpeed"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_4 = state._tr_CCInitialisationFinished(isCaching);
+ for param in _trid_4.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.CCInitialisationFinished(_tmp_2, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("CCInitialisationFinished")); }
+ result.insert((copiedState, "CCInitialisationFinished"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_CCInitialisationDelayFinished(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.CCInitialisationDelayFinished();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("CCInitialisationDelayFinished")); }
+ result.insert((copiedState, "CCInitialisationDelayFinished"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_6 = state._tr_CruiseSpeedChangeFinished(isCaching);
+ for param in _trid_6.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.CruiseSpeedChangeFinished(_tmp_2, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("CruiseSpeedChangeFinished")); }
+ result.insert((copiedState, "CruiseSpeedChangeFinished"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_CruiseSpeedChangeDelayFinished(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.CruiseSpeedChangeDelayFinished();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("CruiseSpeedChangeDelayFinished")); }
+ result.insert((copiedState, "CruiseSpeedChangeDelayFinished"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_CruiseOff(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.CruiseOff();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("CruiseOff")); }
+ result.insert((copiedState, "CruiseOff"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_ExternalForcesBecomesExtreme(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.ExternalForcesBecomesExtreme();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("ExternalForcesBecomesExtreme")); }
+ result.insert((copiedState, "ExternalForcesBecomesExtreme"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_ExternalForcesBecomesNormal(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.ExternalForcesBecomesNormal();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("ExternalForcesBecomesNormal")); }
+ result.insert((copiedState, "ExternalForcesBecomesNormal"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_VehicleLeavesCruiseSpeed(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.VehicleLeavesCruiseSpeed();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("VehicleLeavesCruiseSpeed")); }
+ result.insert((copiedState, "VehicleLeavesCruiseSpeed"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_VehicleReachesCruiseSpeed(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.VehicleReachesCruiseSpeed();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("VehicleReachesCruiseSpeed")); }
+ result.insert((copiedState, "VehicleReachesCruiseSpeed"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_VehicleExceedsMaxCruiseSpeed(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.VehicleExceedsMaxCruiseSpeed();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("VehicleExceedsMaxCruiseSpeed")); }
+ result.insert((copiedState, "VehicleExceedsMaxCruiseSpeed"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_VehicleFallsBelowMaxCruiseSpeed(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.VehicleFallsBelowMaxCruiseSpeed();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("VehicleFallsBelowMaxCruiseSpeed")); }
+ result.insert((copiedState, "VehicleFallsBelowMaxCruiseSpeed"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_ObstacleDistanceBecomesVeryClose(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.ObstacleDistanceBecomesVeryClose();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("ObstacleDistanceBecomesVeryClose")); }
+ result.insert((copiedState, "ObstacleDistanceBecomesVeryClose"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_ObstacleDistanceBecomesClose(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.ObstacleDistanceBecomesClose();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("ObstacleDistanceBecomesClose")); }
+ result.insert((copiedState, "ObstacleDistanceBecomesClose"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_ObstacleDistanceBecomesBig(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.ObstacleDistanceBecomesBig();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("ObstacleDistanceBecomesBig")); }
+ result.insert((copiedState, "ObstacleDistanceBecomesBig"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_ObstacleStartsTravelFaster(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.ObstacleStartsTravelFaster();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("ObstacleStartsTravelFaster")); }
+ result.insert((copiedState, "ObstacleStartsTravelFaster"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_ObstacleStopsTravelFaster(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.ObstacleStopsTravelFaster();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("ObstacleStopsTravelFaster")); }
+ result.insert((copiedState, "ObstacleStopsTravelFaster"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_ObstacleStartsTravelSlower(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.ObstacleStartsTravelSlower();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("ObstacleStartsTravelSlower")); }
+ result.insert((copiedState, "ObstacleStartsTravelSlower"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_ObstacleStopsTravelSlower(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.ObstacleStopsTravelSlower();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("ObstacleStopsTravelSlower")); }
+ result.insert((copiedState, "ObstacleStopsTravelSlower"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_22 = state._tr_ObstacleAppearsWhenCruiseActive(isCaching);
+ for param in _trid_22.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.ObstacleAppearsWhenCruiseActive(_tmp_2, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("ObstacleAppearsWhenCruiseActive")); }
+ result.insert((copiedState, "ObstacleAppearsWhenCruiseActive"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_23 = state._tr_ObstacleAppearsWhenCruiseInactive(isCaching);
+ for param in _trid_23.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.ObstacleAppearsWhenCruiseInactive(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("ObstacleAppearsWhenCruiseInactive")); }
+ result.insert((copiedState, "ObstacleAppearsWhenCruiseInactive"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_ObstacleDisappears(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.ObstacleDisappears();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("ObstacleDisappears")); }
+ result.insert((copiedState, "ObstacleDisappears"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_25 = state._tr_VehicleManageObstacle(isCaching);
+ for param in _trid_25.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.VehicleManageObstacle(_tmp_2, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("VehicleManageObstacle")); }
+ result.insert((copiedState, "VehicleManageObstacle"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_ObstacleBecomesOld(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.ObstacleBecomesOld();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("ObstacleBecomesOld")); }
+ result.insert((copiedState, "ObstacleBecomesOld"));
+ evaluated_transitions += 1;
+ }
+
+
+ transitions.fetch_add(evaluated_transitions, Ordering::AcqRel);
+ return result;
+ }
+
+ //model_check_invariants
+ pub fn checkInvariants(state: &Cruise_finite1_deterministic_MC, last_op: &'static str, isCaching: bool) -> bool {
+ if isCaching {
+ let dependent_invariants_of_state = Self::get_invariant_dependencies(last_op);
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_1") {
+ if !state._check_inv_1() {
+ println!("_check_inv_1 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_2") {
+ if !state._check_inv_2() {
+ println!("_check_inv_2 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_3") {
+ if !state._check_inv_3() {
+ println!("_check_inv_3 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_4") {
+ if !state._check_inv_4() {
+ println!("_check_inv_4 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_5") {
+ if !state._check_inv_5() {
+ println!("_check_inv_5 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_6") {
+ if !state._check_inv_6() {
+ println!("_check_inv_6 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_7") {
+ if !state._check_inv_7() {
+ println!("_check_inv_7 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_8") {
+ if !state._check_inv_8() {
+ println!("_check_inv_8 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_9") {
+ if !state._check_inv_9() {
+ println!("_check_inv_9 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_10") {
+ if !state._check_inv_10() {
+ println!("_check_inv_10 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_11") {
+ if !state._check_inv_11() {
+ println!("_check_inv_11 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_12") {
+ if !state._check_inv_12() {
+ println!("_check_inv_12 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_13") {
+ if !state._check_inv_13() {
+ println!("_check_inv_13 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_14") {
+ if !state._check_inv_14() {
+ println!("_check_inv_14 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_15") {
+ if !state._check_inv_15() {
+ println!("_check_inv_15 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_16") {
+ if !state._check_inv_16() {
+ println!("_check_inv_16 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_17") {
+ if !state._check_inv_17() {
+ println!("_check_inv_17 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_18") {
+ if !state._check_inv_18() {
+ println!("_check_inv_18 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_19") {
+ if !state._check_inv_19() {
+ println!("_check_inv_19 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_20") {
+ if !state._check_inv_20() {
+ println!("_check_inv_20 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_21") {
+ if !state._check_inv_21() {
+ println!("_check_inv_21 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_22") {
+ if !state._check_inv_22() {
+ println!("_check_inv_22 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_23") {
+ if !state._check_inv_23() {
+ println!("_check_inv_23 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_24") {
+ if !state._check_inv_24() {
+ println!("_check_inv_24 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_25") {
+ if !state._check_inv_25() {
+ println!("_check_inv_25 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_26") {
+ if !state._check_inv_26() {
+ println!("_check_inv_26 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_27") {
+ if !state._check_inv_27() {
+ println!("_check_inv_27 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_28") {
+ if !state._check_inv_28() {
+ println!("_check_inv_28 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_29") {
+ if !state._check_inv_29() {
+ println!("_check_inv_29 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_30") {
+ if !state._check_inv_30() {
+ println!("_check_inv_30 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_31") {
+ if !state._check_inv_31() {
+ println!("_check_inv_31 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_32") {
+ if !state._check_inv_32() {
+ println!("_check_inv_32 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_33") {
+ if !state._check_inv_33() {
+ println!("_check_inv_33 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_34") {
+ if !state._check_inv_34() {
+ println!("_check_inv_34 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_35") {
+ if !state._check_inv_35() {
+ println!("_check_inv_35 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_36") {
+ if !state._check_inv_36() {
+ println!("_check_inv_36 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_37") {
+ if !state._check_inv_37() {
+ println!("_check_inv_37 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_38") {
+ if !state._check_inv_38() {
+ println!("_check_inv_38 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_39") {
+ if !state._check_inv_39() {
+ println!("_check_inv_39 failed!");
+ return false;
+ }
+ }
+ return true;
+ }
+ return !(!state._check_inv_1() || !state._check_inv_2() || !state._check_inv_3() || !state._check_inv_4() || !state._check_inv_5() || !state._check_inv_6() || !state._check_inv_7() || !state._check_inv_8() || !state._check_inv_9() || !state._check_inv_10() || !state._check_inv_11() || !state._check_inv_12() || !state._check_inv_13() || !state._check_inv_14() || !state._check_inv_15() || !state._check_inv_16() || !state._check_inv_17() || !state._check_inv_18() || !state._check_inv_19() || !state._check_inv_20() || !state._check_inv_21() || !state._check_inv_22() || !state._check_inv_23() || !state._check_inv_24() || !state._check_inv_25() || !state._check_inv_26() || !state._check_inv_27() || !state._check_inv_28() || !state._check_inv_29() || !state._check_inv_30() || !state._check_inv_31() || !state._check_inv_32() || !state._check_inv_33() || !state._check_inv_34() || !state._check_inv_35() || !state._check_inv_36() || !state._check_inv_37() || !state._check_inv_38() || !state._check_inv_39());
+ }
+
+ //model_check_print
+ fn print_result(states: usize, transitions: u64, error_detected: bool) {
+ if !error_detected { println!("MODEL CHECKING SUCCESSFUL"); }
+ println!("Number of States: {}", states);
+ println!("Number of Transitions: {}", transitions);
+ }
+
+ //model_check_main
+ fn next(collection_m: Arc<Mutex<LinkedList<(Cruise_finite1_deterministic_MC, &'static str)>>>, mc_type: MC_TYPE) -> (Cruise_finite1_deterministic_MC, &'static str) {
+ let mut collection = collection_m.lock().unwrap();
+ return match mc_type {
+ MC_TYPE::BFS => collection.pop_front().unwrap(),
+ MC_TYPE::DFS => collection.pop_back().unwrap(),
+ MC_TYPE::MIXED => if collection.len() % 2 == 0 { collection.pop_front().unwrap() } else { collection.pop_back().unwrap() }
+ };
+ }
+
+ fn get_guard_dependencies(op: &'static str) -> Vec<&str> {
+ return match op {
+ //model_check_init_static
+ "ObstacleStopsTravelSlower" => vec!["_tr_ObstacleStopsTravelFaster", "_tr_ObstacleStopsTravelSlower", "_tr_VehicleManageObstacle", "_tr_ObstacleDistanceBecomesBig", "_tr_ObstacleDistanceBecomesClose", "_tr_CruiseSpeedChangeFinished", "_tr_CCInitialisationFinished", "_tr_CCInitialisationDelayFinished", "_tr_CruiseSpeedChangeDelayFinished", "_tr_ObstacleStartsTravelSlower", "_tr_ObstacleStartsTravelFaster", "_tr_VehicleExceedsMaxCruiseSpeed", "_tr_ObstacleBecomesOld", "_tr_ObstacleDistanceBecomesVeryClose"],
+ //model_check_init_static
+ "SetCruiseSpeed" => vec!["_tr_VehicleManageObstacle", "_tr_ObstacleDistanceBecomesClose", "_tr_ExternalForcesBecomesNormal", "_tr_CruiseSpeedChangeFinished", "_tr_ExternalForcesBecomesExtreme", "_tr_CCInitialisationFinished", "_tr_CCInitialisationDelayFinished", "_tr_CruiseSpeedChangeDelayFinished", "_tr_VehicleLeavesCruiseSpeed", "_tr_ObstacleAppearsWhenCruiseActive", "_tr_VehicleReachesCruiseSpeed", "_tr_CruiseOff", "_tr_VehicleExceedsMaxCruiseSpeed", "_tr_ObstacleBecomesOld", "_tr_ObstacleAppearsWhenCruiseInactive"],
+ //model_check_init_static
+ "VehicleLeavesCruiseSpeed" => vec!["_tr_VehicleReachesCruiseSpeed", "_tr_VehicleLeavesCruiseSpeed"],
+ //model_check_init_static
+ "VehicleFallsBelowMaxCruiseSpeed" => vec!["_tr_VehicleReachesCruiseSpeed", "_tr_VehicleFallsBelowMaxCruiseSpeed", "_tr_VehicleExceedsMaxCruiseSpeed", "_tr_VehicleLeavesCruiseSpeed"],
+ //model_check_init_static
+ "CCInitialisationFinished" => vec!["_tr_ObstacleBecomesOld", "_tr_CCInitialisationDelayFinished", "_tr_CruiseSpeedChangeDelayFinished", "_tr_VehicleLeavesCruiseSpeed"],
+ //model_check_init_static
+ "VehicleReachesCruiseSpeed" => vec!["_tr_VehicleReachesCruiseSpeed", "_tr_VehicleLeavesCruiseSpeed"],
+ //model_check_init_static
+ "ObstacleAppearsWhenCruiseActive" => vec!["_tr_ObstacleStopsTravelFaster", "_tr_ObstacleStopsTravelSlower", "_tr_VehicleManageObstacle", "_tr_ObstacleDistanceBecomesBig", "_tr_ObstacleDistanceBecomesClose", "_tr_CruiseSpeedChangeFinished", "_tr_ObstacleDisappears", "_tr_CCInitialisationFinished", "_tr_CCInitialisationDelayFinished", "_tr_CruiseSpeedChangeDelayFinished", "_tr_ObstacleStartsTravelSlower", "_tr_ObstacleStartsTravelFaster", "_tr_ObstacleAppearsWhenCruiseActive", "_tr_VehicleExceedsMaxCruiseSpeed", "_tr_ObstacleBecomesOld", "_tr_ObstacleDistanceBecomesVeryClose", "_tr_ObstacleAppearsWhenCruiseInactive"],
+ //model_check_init_static
+ "ObstacleStartsTravelSlower" => vec!["_tr_ObstacleStopsTravelFaster", "_tr_ObstacleStopsTravelSlower", "_tr_VehicleManageObstacle", "_tr_ObstacleDistanceBecomesBig", "_tr_ObstacleDistanceBecomesClose", "_tr_CruiseSpeedChangeFinished", "_tr_CCInitialisationFinished", "_tr_CCInitialisationDelayFinished", "_tr_CruiseSpeedChangeDelayFinished", "_tr_ObstacleStartsTravelSlower", "_tr_ObstacleStartsTravelFaster", "_tr_VehicleExceedsMaxCruiseSpeed", "_tr_ObstacleBecomesOld", "_tr_ObstacleDistanceBecomesVeryClose"],
+ //model_check_init_static
+ "CruiseBecomesNotAllowed" => vec!["_tr_SetCruiseSpeed", "_tr_VehicleManageObstacle", "_tr_CruiseBecomesAllowed", "_tr_ObstacleDistanceBecomesBig", "_tr_ObstacleDistanceBecomesClose", "_tr_CruiseBecomesNotAllowed", "_tr_ExternalForcesBecomesNormal", "_tr_CruiseSpeedChangeFinished", "_tr_ExternalForcesBecomesExtreme", "_tr_CCInitialisationFinished", "_tr_CCInitialisationDelayFinished", "_tr_CruiseSpeedChangeDelayFinished", "_tr_VehicleLeavesCruiseSpeed", "_tr_ObstacleAppearsWhenCruiseActive", "_tr_VehicleReachesCruiseSpeed", "_tr_CruiseOff", "_tr_VehicleExceedsMaxCruiseSpeed", "_tr_ObstacleBecomesOld", "_tr_ObstacleDistanceBecomesVeryClose", "_tr_ObstacleAppearsWhenCruiseInactive"],
+ //model_check_init_static
+ "ObstacleAppearsWhenCruiseInactive" => vec!["_tr_ObstacleStopsTravelFaster", "_tr_ObstacleStopsTravelSlower", "_tr_VehicleManageObstacle", "_tr_ObstacleDistanceBecomesBig", "_tr_ObstacleDistanceBecomesClose", "_tr_CruiseSpeedChangeFinished", "_tr_ObstacleDisappears", "_tr_CCInitialisationFinished", "_tr_CCInitialisationDelayFinished", "_tr_CruiseSpeedChangeDelayFinished", "_tr_ObstacleStartsTravelSlower", "_tr_ObstacleStartsTravelFaster", "_tr_ObstacleAppearsWhenCruiseActive", "_tr_ObstacleBecomesOld", "_tr_ObstacleDistanceBecomesVeryClose", "_tr_ObstacleAppearsWhenCruiseInactive"],
+ //model_check_init_static
+ "CCInitialisationDelayFinished" => vec!["_tr_VehicleManageObstacle", "_tr_VehicleExceedsMaxCruiseSpeed", "_tr_CruiseSpeedChangeFinished", "_tr_ObstacleBecomesOld", "_tr_CCInitialisationFinished", "_tr_CCInitialisationDelayFinished", "_tr_CruiseSpeedChangeDelayFinished"],
+ //model_check_init_static
+ "ObstacleDistanceBecomesClose" => vec!["_tr_VehicleManageObstacle", "_tr_ObstacleDistanceBecomesBig", "_tr_ObstacleDistanceBecomesClose", "_tr_VehicleExceedsMaxCruiseSpeed", "_tr_CruiseSpeedChangeFinished", "_tr_ObstacleBecomesOld", "_tr_ObstacleDistanceBecomesVeryClose", "_tr_CCInitialisationFinished", "_tr_CCInitialisationDelayFinished", "_tr_CruiseSpeedChangeDelayFinished"],
+ //model_check_init_static
+ "ObstacleStartsTravelFaster" => vec!["_tr_ObstacleStopsTravelFaster", "_tr_ObstacleStopsTravelSlower", "_tr_VehicleManageObstacle", "_tr_ObstacleDistanceBecomesBig", "_tr_ObstacleDistanceBecomesClose", "_tr_CruiseSpeedChangeFinished", "_tr_CCInitialisationFinished", "_tr_CCInitialisationDelayFinished", "_tr_CruiseSpeedChangeDelayFinished", "_tr_ObstacleStartsTravelSlower", "_tr_ObstacleStartsTravelFaster", "_tr_VehicleExceedsMaxCruiseSpeed", "_tr_ObstacleBecomesOld", "_tr_ObstacleDistanceBecomesVeryClose"],
+ //model_check_init_static
+ "ExternalForcesBecomesExtreme" => vec!["_tr_ExternalForcesBecomesNormal", "_tr_VehicleExceedsMaxCruiseSpeed", "_tr_ExternalForcesBecomesExtreme", "_tr_VehicleLeavesCruiseSpeed"],
+ //model_check_init_static
+ "CruiseOff" => vec!["_tr_VehicleManageObstacle", "_tr_ObstacleDistanceBecomesBig", "_tr_ObstacleDistanceBecomesClose", "_tr_ExternalForcesBecomesNormal", "_tr_CruiseSpeedChangeFinished", "_tr_ExternalForcesBecomesExtreme", "_tr_CCInitialisationFinished", "_tr_CCInitialisationDelayFinished", "_tr_CruiseSpeedChangeDelayFinished", "_tr_VehicleLeavesCruiseSpeed", "_tr_ObstacleAppearsWhenCruiseActive", "_tr_VehicleReachesCruiseSpeed", "_tr_CruiseOff", "_tr_VehicleExceedsMaxCruiseSpeed", "_tr_ObstacleBecomesOld", "_tr_ObstacleDistanceBecomesVeryClose", "_tr_ObstacleAppearsWhenCruiseInactive"],
+ //model_check_init_static
+ "CruiseSpeedChangeDelayFinished" => vec!["_tr_VehicleManageObstacle", "_tr_VehicleExceedsMaxCruiseSpeed", "_tr_CruiseSpeedChangeFinished", "_tr_ObstacleBecomesOld", "_tr_CCInitialisationFinished", "_tr_CCInitialisationDelayFinished", "_tr_CruiseSpeedChangeDelayFinished"],
+ //model_check_init_static
+ "ObstacleStopsTravelFaster" => vec!["_tr_ObstacleStopsTravelFaster", "_tr_ObstacleStopsTravelSlower", "_tr_VehicleManageObstacle", "_tr_ObstacleDistanceBecomesBig", "_tr_ObstacleDistanceBecomesClose", "_tr_CruiseSpeedChangeFinished", "_tr_CCInitialisationFinished", "_tr_CCInitialisationDelayFinished", "_tr_CruiseSpeedChangeDelayFinished", "_tr_ObstacleStartsTravelSlower", "_tr_ObstacleStartsTravelFaster", "_tr_VehicleExceedsMaxCruiseSpeed", "_tr_ObstacleBecomesOld", "_tr_ObstacleDistanceBecomesVeryClose"],
+ //model_check_init_static
+ "ObstacleDistanceBecomesVeryClose" => vec!["_tr_VehicleManageObstacle", "_tr_ObstacleDistanceBecomesBig", "_tr_ObstacleDistanceBecomesClose", "_tr_VehicleExceedsMaxCruiseSpeed", "_tr_CruiseSpeedChangeFinished", "_tr_ObstacleBecomesOld", "_tr_ObstacleDistanceBecomesVeryClose", "_tr_CCInitialisationFinished", "_tr_CCInitialisationDelayFinished", "_tr_CruiseSpeedChangeDelayFinished"],
+ //model_check_init_static
+ "VehicleManageObstacle" => vec!["_tr_ObstacleBecomesOld", "_tr_CCInitialisationDelayFinished", "_tr_CruiseSpeedChangeDelayFinished", "_tr_VehicleLeavesCruiseSpeed"],
+ //model_check_init_static
+ "CruiseBecomesAllowed" => vec!["_tr_SetCruiseSpeed", "_tr_CruiseBecomesAllowed", "_tr_CruiseBecomesNotAllowed"],
+ //model_check_init_static
+ "VehicleExceedsMaxCruiseSpeed" => vec!["_tr_VehicleReachesCruiseSpeed", "_tr_VehicleFallsBelowMaxCruiseSpeed", "_tr_VehicleExceedsMaxCruiseSpeed", "_tr_VehicleLeavesCruiseSpeed"],
+ //model_check_init_static
+ "CruiseSpeedChangeFinished" => vec!["_tr_ObstacleBecomesOld", "_tr_CCInitialisationDelayFinished", "_tr_CruiseSpeedChangeDelayFinished", "_tr_VehicleLeavesCruiseSpeed"],
+ //model_check_init_static
+ "ObstacleDisappears" => vec!["_tr_ObstacleStopsTravelFaster", "_tr_ObstacleStopsTravelSlower", "_tr_VehicleManageObstacle", "_tr_ObstacleDistanceBecomesBig", "_tr_ObstacleDistanceBecomesClose", "_tr_CruiseSpeedChangeFinished", "_tr_ObstacleDisappears", "_tr_CCInitialisationFinished", "_tr_CCInitialisationDelayFinished", "_tr_CruiseSpeedChangeDelayFinished", "_tr_ObstacleStartsTravelSlower", "_tr_ObstacleStartsTravelFaster", "_tr_ObstacleAppearsWhenCruiseActive", "_tr_VehicleExceedsMaxCruiseSpeed", "_tr_ObstacleBecomesOld", "_tr_ObstacleDistanceBecomesVeryClose", "_tr_ObstacleAppearsWhenCruiseInactive"],
+ //model_check_init_static
+ "ExternalForcesBecomesNormal" => vec!["_tr_ExternalForcesBecomesNormal", "_tr_VehicleExceedsMaxCruiseSpeed", "_tr_ExternalForcesBecomesExtreme", "_tr_VehicleLeavesCruiseSpeed"],
+ //model_check_init_static
+ "ObstacleBecomesOld" => vec!["_tr_VehicleManageObstacle", "_tr_VehicleExceedsMaxCruiseSpeed", "_tr_CruiseSpeedChangeFinished", "_tr_ObstacleBecomesOld", "_tr_CCInitialisationFinished", "_tr_CCInitialisationDelayFinished", "_tr_CruiseSpeedChangeDelayFinished"],
+ //model_check_init_static
+ "ObstacleDistanceBecomesBig" => vec!["_tr_VehicleManageObstacle", "_tr_ObstacleDistanceBecomesBig", "_tr_ObstacleDistanceBecomesClose", "_tr_VehicleExceedsMaxCruiseSpeed", "_tr_CruiseSpeedChangeFinished", "_tr_ObstacleBecomesOld", "_tr_ObstacleDistanceBecomesVeryClose", "_tr_CCInitialisationFinished", "_tr_CCInitialisationDelayFinished", "_tr_CruiseSpeedChangeDelayFinished"],
+ _ => vec![],
+ }
+ }
+
+ fn get_invariant_dependencies(op: &'static str) -> Vec<&str> {
+ return match op {
+ //model_check_init_static
+ "ObstacleStopsTravelSlower" => vec!["_check_inv_29", "_check_inv_39", "_check_inv_38", "_check_inv_37", "_check_inv_32", "_check_inv_31", "_check_inv_30", "_check_inv_14", "_check_inv_36", "_check_inv_13", "_check_inv_35", "_check_inv_24"],
+ //model_check_init_static
+ "SetCruiseSpeed" => vec!["_check_inv_18", "_check_inv_17", "_check_inv_39", "_check_inv_16", "_check_inv_38", "_check_inv_15", "_check_inv_37", "_check_inv_19", "_check_inv_10", "_check_inv_14", "_check_inv_36", "_check_inv_35", "_check_inv_34", "_check_inv_33", "_check_inv_26", "_check_inv_21", "_check_inv_20", "_check_inv_4", "_check_inv_25", "_check_inv_24", "_check_inv_8", "_check_inv_23", "_check_inv_9", "_check_inv_22", "_check_inv_2", "_check_inv_3"],
+ //model_check_init_static
+ "VehicleLeavesCruiseSpeed" => vec!["_check_inv_17", "_check_inv_3", "_check_inv_34"],
+ //model_check_init_static
+ "VehicleFallsBelowMaxCruiseSpeed" => vec!["_check_inv_17", "_check_inv_3", "_check_inv_6", "_check_inv_34"],
+ //model_check_init_static
+ "CCInitialisationFinished" => vec!["_check_inv_39", "_check_inv_38", "_check_inv_27", "_check_inv_37", "_check_inv_19", "_check_inv_32", "_check_inv_21", "_check_inv_31", "_check_inv_7", "_check_inv_30", "_check_inv_5", "_check_inv_36", "_check_inv_35"],
+ //model_check_init_static
+ "VehicleReachesCruiseSpeed" => vec!["_check_inv_17", "_check_inv_3", "_check_inv_34"],
+ //model_check_init_static
+ "ObstacleAppearsWhenCruiseActive" => vec!["_check_inv_29", "_check_inv_39", "_check_inv_28", "_check_inv_38", "_check_inv_27", "_check_inv_37", "_check_inv_32", "_check_inv_31", "_check_inv_30", "_check_inv_14", "_check_inv_36", "_check_inv_13", "_check_inv_35", "_check_inv_24", "_check_inv_12", "_check_inv_23", "_check_inv_11"],
+ //model_check_init_static
+ "ObstacleStartsTravelSlower" => vec!["_check_inv_29", "_check_inv_39", "_check_inv_38", "_check_inv_37", "_check_inv_32", "_check_inv_31", "_check_inv_30", "_check_inv_14", "_check_inv_36", "_check_inv_13", "_check_inv_35", "_check_inv_24"],
+ //model_check_init_static
+ "CruiseBecomesNotAllowed" => vec!["_check_inv_18", "_check_inv_17", "_check_inv_39", "_check_inv_16", "_check_inv_38", "_check_inv_15", "_check_inv_37", "_check_inv_19", "_check_inv_10", "_check_inv_32", "_check_inv_31", "_check_inv_30", "_check_inv_14", "_check_inv_36", "_check_inv_35", "_check_inv_12", "_check_inv_34", "_check_inv_33", "_check_inv_28", "_check_inv_27", "_check_inv_26", "_check_inv_21", "_check_inv_7", "_check_inv_20", "_check_inv_4", "_check_inv_5", "_check_inv_25", "_check_inv_24", "_check_inv_8", "_check_inv_23", "_check_inv_9", "_check_inv_22", "_check_inv_2", "_check_inv_3", "_check_inv_1"],
+ //model_check_init_static
+ "ObstacleAppearsWhenCruiseInactive" => vec!["_check_inv_29", "_check_inv_39", "_check_inv_28", "_check_inv_38", "_check_inv_27", "_check_inv_37", "_check_inv_32", "_check_inv_31", "_check_inv_30", "_check_inv_36", "_check_inv_13", "_check_inv_12", "_check_inv_23", "_check_inv_11"],
+ //model_check_init_static
+ "CCInitialisationDelayFinished" => vec!["_check_inv_39", "_check_inv_38", "_check_inv_15", "_check_inv_37", "_check_inv_36", "_check_inv_25", "_check_inv_35"],
+ //model_check_init_static
+ "ObstacleDistanceBecomesClose" => vec!["_check_inv_39", "_check_inv_28", "_check_inv_38", "_check_inv_27", "_check_inv_37", "_check_inv_32", "_check_inv_21", "_check_inv_31", "_check_inv_7", "_check_inv_30", "_check_inv_14", "_check_inv_36", "_check_inv_35", "_check_inv_24", "_check_inv_12", "_check_inv_23"],
+ //model_check_init_static
+ "ObstacleStartsTravelFaster" => vec!["_check_inv_29", "_check_inv_39", "_check_inv_38", "_check_inv_27", "_check_inv_37", "_check_inv_32", "_check_inv_21", "_check_inv_31", "_check_inv_7", "_check_inv_30", "_check_inv_14", "_check_inv_36", "_check_inv_13", "_check_inv_35", "_check_inv_24"],
+ //model_check_init_static
+ "ExternalForcesBecomesExtreme" => vec!["_check_inv_18", "_check_inv_4"],
+ //model_check_init_static
+ "CruiseOff" => vec!["_check_inv_18", "_check_inv_17", "_check_inv_39", "_check_inv_16", "_check_inv_38", "_check_inv_15", "_check_inv_37", "_check_inv_19", "_check_inv_10", "_check_inv_32", "_check_inv_31", "_check_inv_30", "_check_inv_14", "_check_inv_36", "_check_inv_35", "_check_inv_12", "_check_inv_34", "_check_inv_33", "_check_inv_28", "_check_inv_27", "_check_inv_26", "_check_inv_21", "_check_inv_7", "_check_inv_20", "_check_inv_4", "_check_inv_5", "_check_inv_25", "_check_inv_24", "_check_inv_8", "_check_inv_23", "_check_inv_9", "_check_inv_22", "_check_inv_2", "_check_inv_3"],
+ //model_check_init_static
+ "CruiseSpeedChangeDelayFinished" => vec!["_check_inv_39", "_check_inv_16", "_check_inv_38", "_check_inv_37", "_check_inv_26", "_check_inv_36", "_check_inv_35"],
+ //model_check_init_static
+ "ObstacleStopsTravelFaster" => vec!["_check_inv_29", "_check_inv_39", "_check_inv_38", "_check_inv_37", "_check_inv_32", "_check_inv_31", "_check_inv_30", "_check_inv_14", "_check_inv_36", "_check_inv_13", "_check_inv_35", "_check_inv_24"],
+ //model_check_init_static
+ "ObstacleDistanceBecomesVeryClose" => vec!["_check_inv_39", "_check_inv_28", "_check_inv_38", "_check_inv_37", "_check_inv_32", "_check_inv_31", "_check_inv_30", "_check_inv_14", "_check_inv_36", "_check_inv_35", "_check_inv_24", "_check_inv_12", "_check_inv_23"],
+ //model_check_init_static
+ "VehicleManageObstacle" => vec!["_check_inv_39", "_check_inv_38", "_check_inv_27", "_check_inv_37", "_check_inv_19", "_check_inv_32", "_check_inv_21", "_check_inv_31", "_check_inv_7", "_check_inv_30", "_check_inv_5", "_check_inv_36", "_check_inv_35"],
+ //model_check_init_static
+ "CruiseBecomesAllowed" => vec!["_check_inv_1", "_check_inv_33"],
+ //model_check_init_static
+ "VehicleExceedsMaxCruiseSpeed" => vec!["_check_inv_17", "_check_inv_3", "_check_inv_6", "_check_inv_34"],
+ //model_check_init_static
+ "CruiseSpeedChangeFinished" => vec!["_check_inv_39", "_check_inv_38", "_check_inv_27", "_check_inv_37", "_check_inv_19", "_check_inv_32", "_check_inv_21", "_check_inv_31", "_check_inv_7", "_check_inv_30", "_check_inv_5", "_check_inv_36", "_check_inv_35"],
+ //model_check_init_static
+ "ObstacleDisappears" => vec!["_check_inv_29", "_check_inv_39", "_check_inv_28", "_check_inv_38", "_check_inv_27", "_check_inv_37", "_check_inv_32", "_check_inv_21", "_check_inv_31", "_check_inv_7", "_check_inv_30", "_check_inv_14", "_check_inv_36", "_check_inv_13", "_check_inv_35", "_check_inv_24", "_check_inv_12", "_check_inv_23", "_check_inv_11"],
+ //model_check_init_static
+ "ExternalForcesBecomesNormal" => vec!["_check_inv_18", "_check_inv_4"],
+ //model_check_init_static
+ "ObstacleBecomesOld" => vec!["_check_inv_39", "_check_inv_38", "_check_inv_37", "_check_inv_14", "_check_inv_36", "_check_inv_35", "_check_inv_24"],
+ //model_check_init_static
+ "ObstacleDistanceBecomesBig" => vec!["_check_inv_39", "_check_inv_28", "_check_inv_38", "_check_inv_27", "_check_inv_37", "_check_inv_32", "_check_inv_21", "_check_inv_31", "_check_inv_7", "_check_inv_30", "_check_inv_14", "_check_inv_36", "_check_inv_35", "_check_inv_24", "_check_inv_12", "_check_inv_23"],
+ _ => vec![],
+ }
+ }
+
+ fn model_check_single_threaded(mc_type: MC_TYPE, is_caching: bool, no_dead: bool, no_inv: bool) {
+ let mut machine = Cruise_finite1_deterministic_MC::new();
+
+ let mut all_states = HashSet::<Cruise_finite1_deterministic_MC>::new();
+ all_states.insert(machine.clone());
+
+ let states_to_process_mutex = Arc::new(Mutex::new(LinkedList::<(Cruise_finite1_deterministic_MC, &'static str)>::new()));
+ states_to_process_mutex.lock().unwrap().push_back((machine.clone(), ""));
+
+ let num_transitions = Arc::new(AtomicU64::new(0));
+
+ let mut stop_threads = false;
+
+ while !stop_threads && !states_to_process_mutex.lock().unwrap().is_empty() {
+ let (mut state, last_op) = Self::next(Arc::clone(&states_to_process_mutex), mc_type);
+
+ let next_states = Self::generateNextStates(&mut state, is_caching, Arc::clone(&num_transitions));
+
+ if !no_inv && !Self::checkInvariants(&state, last_op, is_caching) {
+ println!("INVARIANT VIOLATED");
+ stop_threads = true;
+ }
+ if !no_dead && next_states.is_empty() {
+ print!("DEADLOCK DETECTED");
+ stop_threads = true;
+ }
+
+ next_states.into_iter()
+ .filter(|(next_state, _)| all_states.insert((*next_state).clone()))
+ .for_each(|(next_state, last_op)| states_to_process_mutex.lock().unwrap().push_back((next_state, last_op)));
+
+ if all_states.len() % 50000 == 0 {
+ println!("VISITED STATES: {}", all_states.len());
+ println!("EVALUATED TRANSITIONS: {}", num_transitions.load(Ordering::Acquire));
+ println!("-------------------");
+ }
+ }
+ Self::print_result(all_states.len(), num_transitions.load(Ordering::Acquire), stop_threads);
+ }
+
+ fn modelCheckMultiThreaded(mc_type: MC_TYPE, threads: usize, is_caching: bool, no_dead: bool, no_inv: bool) {
+ let threadPool = ThreadPool::new(threads);
+
+ let machine = Cruise_finite1_deterministic_MC::new();
+
+ let all_states = Arc::new(DashSet::<Cruise_finite1_deterministic_MC>::new());
+ all_states.insert(machine.clone());
+
+ let states_to_process_mutex = Arc::new(Mutex::new(LinkedList::<(Cruise_finite1_deterministic_MC, &'static str)>::new()));
+ states_to_process_mutex.lock().unwrap().push_back((machine, ""));
+
+ let num_transitions = Arc::new(AtomicU64::new(0));
+
+ let mut stop_threads = false;
+ let mut spawned_tasks: u64 = 0;
+ let mut finished_tasks: u64 = 0;
+
+ let (tx, rx) = channel();
+ //println!("Thread {:?} starting threads", thread::current().id());
+ while !stop_threads && !states_to_process_mutex.lock().unwrap().is_empty() {
+ let (mut state, last_op) = Self::next(Arc::clone(&states_to_process_mutex), mc_type);
+
+ let states_to_process = Arc::clone(&states_to_process_mutex);
+ let transitions = Arc::clone(&num_transitions);
+ let states = Arc::clone(&all_states);
+ let tx = tx.clone();
+ //println!("Thread {:?} spawning a thread", thread::current().id());
+ threadPool.execute(move|| {
+ let next_states = Self::generateNextStates(&mut state, is_caching, transitions);
+ if !no_dead && next_states.is_empty() { let _ = tx.send(Err("DEADLOCK DETECTED")); }
+
+ //println!("Thread {:?} executing", thread::current().id());
+ next_states.into_iter()
+ .filter(|(next_state, _)| states.insert((*next_state).clone()))
+ .for_each(|(next_state, last_op)| states_to_process.lock().unwrap().push_back((next_state, last_op)));
+
+ if !no_inv && !Self::checkInvariants(&state, last_op, is_caching) {
+ let _ = tx.send(Err("INVARIANT VIOLATED"));
+ }
+ //println!("Thread {:?} done", thread::current().id());
+ let _ = tx.send(Ok(1));
+ });
+
+ spawned_tasks += 1;
+ if spawned_tasks % 50000 == 0 {
+ println!("VISITED STATES: {}", all_states.len());
+ println!("EVALUATED TRANSITIONS: {}", num_transitions.load(Ordering::Acquire));
+ println!("-------------------");
+ }
+
+ while states_to_process_mutex.lock().unwrap().is_empty() && spawned_tasks - finished_tasks > 0 {
+ //println!("Thread {:?} (main) waiting for a thread to finish", thread::current().id());
+ match rx.try_recv() {
+ Ok(val) => match val {
+ Ok(_) => finished_tasks += 1,
+ Err(msg) => { println!("{}", msg); stop_threads = true; },
+ },
+ Err(_) => (),
+ }
+ if threadPool.panic_count() > 0 { stop_threads = true; }
+ }
+ }
+
+ Self::print_result(all_states.len(), num_transitions.load(Ordering::Acquire), stop_threads);
+ }
+
+}
+
+
+fn main() {
+ let args: Vec<String> = env::args().collect();
+ if args.len() < 4 { panic!("Number of arguments errorneous"); }
+
+ let threads = args.get(2).unwrap().parse::<usize>().unwrap();
+ if threads <= 0 { panic!("Input for number of threads is wrong."); }
+
+ let is_caching = args.get(3).unwrap().parse::<bool>().unwrap();
+ let mc_type = match args.get(1).unwrap().as_str() {
+ "mixed" => MC_TYPE::MIXED,
+ "bf" => MC_TYPE::BFS,
+ "df" => MC_TYPE::DFS,
+ _ => panic!("Input for strategy is wrong.")
+ };
+
+ let mut no_dead = false;
+ let mut no_inv = false;
+
+ if args.len() > 4 {
+ for arg in args.iter().skip(4) {
+ match arg.as_str() {
+ "-nodead" => no_dead = true,
+ "-noinv" => no_inv = true,
+ _ => {}
+ }
+ }
+ }
+
+ if threads == 1 {
+ Cruise_finite1_deterministic_MC::model_check_single_threaded(mc_type, is_caching, no_dead, no_inv);
+ } else {
+ Cruise_finite1_deterministic_MC::modelCheckMultiThreaded(mc_type, threads, is_caching, no_dead, no_inv);
+ }
+}
diff --git a/benchmarks/model_checking/Rust_embedded/LandingGear_R6.rs b/benchmarks/model_checking/Rust_embedded/LandingGear_R6.rs
new file mode 100644
index 000000000..9869748f8
--- /dev/null
+++ b/benchmarks/model_checking/Rust_embedded/LandingGear_R6.rs
@@ -0,0 +1,2717 @@
+#![ allow( dead_code, unused, non_snake_case, non_camel_case_types, unused_assignments ) ]
+//#![no_std] //std is enabled for the generated machine by default, since without it there is no println which makes unit-testing very difficult
+use btypes::{bset, brel};
+use btypes::bset::BSet;
+use btypes::bset::SetItem;
+use btypes::bset::PowSetItem;
+use btypes::bset::PowAble;
+use btypes::bset::NestedSet;
+use btypes::brelation::BRelation;
+use btypes::brelation::RelLeftItem;
+use btypes::brelation::RelPowAble;
+use btypes::bboolean::BBoolean;
+use btypes::bboolean::BBool;
+use btypes::bboolean::BOOL;
+use btypes::binteger::BInteger;
+use btypes::binteger::BInt;
+use btypes::binteger::set_BInteger;
+use btypes::btuple::BTuple;
+
+use std::env;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, mpsc, Mutex};
+use std::collections::{HashSet, LinkedList};
+use dashmap::DashSet;
+use threadpool::ThreadPool;
+use std::sync::mpsc::channel;
+use derivative::Derivative;
+use std::time::{Duration};
+
+
+
+#[derive(Clone, Copy)]
+pub enum MC_TYPE { BFS, DFS, MIXED }
+
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum DOOR_STATE {
+ #[default]
+ open = 0,
+ closed = 1,
+ door_moving = 2
+}
+
+impl DOOR_STATE {
+ pub fn equal(&self, other: &DOOR_STATE) -> bool { *self == *other }
+ pub fn unequal(&self, other: &DOOR_STATE) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::open,
+ 1 => Self::closed,
+ 2 => Self::door_moving,
+ _ => panic!("DOOR_STATE index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<3> for DOOR_STATE {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_DOOR_STATE = BSet<DOOR_STATE, 3>;
+//set_enum_declaration done
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum GEAR_STATE {
+ #[default]
+ retracted = 0,
+ extended = 1,
+ gear_moving = 2
+}
+
+impl GEAR_STATE {
+ pub fn equal(&self, other: &GEAR_STATE) -> bool { *self == *other }
+ pub fn unequal(&self, other: &GEAR_STATE) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::retracted,
+ 1 => Self::extended,
+ 2 => Self::gear_moving,
+ _ => panic!("GEAR_STATE index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<3> for GEAR_STATE {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_GEAR_STATE = BSet<GEAR_STATE, 3>;
+//set_enum_declaration done
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum HANDLE_STATE {
+ #[default]
+ up = 0,
+ down = 1
+}
+
+impl HANDLE_STATE {
+ pub fn equal(&self, other: &HANDLE_STATE) -> bool { *self == *other }
+ pub fn unequal(&self, other: &HANDLE_STATE) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::up,
+ 1 => Self::down,
+ _ => panic!("HANDLE_STATE index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<2> for HANDLE_STATE {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_HANDLE_STATE = BSet<HANDLE_STATE, 2>;
+//set_enum_declaration done
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum POSITION {
+ #[default]
+ fr = 0,
+ lt = 1,
+ rt = 2
+}
+
+impl POSITION {
+ pub fn equal(&self, other: &POSITION) -> bool { *self == *other }
+ pub fn unequal(&self, other: &POSITION) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::fr,
+ 1 => Self::lt,
+ 2 => Self::rt,
+ _ => panic!("POSITION index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<3> for POSITION {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_POSITION = BSet<POSITION, 3>;
+//set_enum_declaration done
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum SWITCH_STATE {
+ #[default]
+ switch_open = 0,
+ switch_closed = 1
+}
+
+impl SWITCH_STATE {
+ pub fn equal(&self, other: &SWITCH_STATE) -> bool { *self == *other }
+ pub fn unequal(&self, other: &SWITCH_STATE) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::switch_open,
+ 1 => Self::switch_closed,
+ _ => panic!("SWITCH_STATE index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<2> for SWITCH_STATE {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_SWITCH_STATE = BSet<SWITCH_STATE, 2>;
+//set_enum_declaration done
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum PLANE_STATE {
+ #[default]
+ ground = 0,
+ flight = 1
+}
+
+impl PLANE_STATE {
+ pub fn equal(&self, other: &PLANE_STATE) -> bool { *self == *other }
+ pub fn unequal(&self, other: &PLANE_STATE) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::ground,
+ 1 => Self::flight,
+ _ => panic!("PLANE_STATE index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<2> for PLANE_STATE {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_PLANE_STATE = BSet<PLANE_STATE, 2>;
+//set_enum_declaration done
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum VALVE_STATE {
+ #[default]
+ valve_open = 0,
+ valve_closed = 1
+}
+
+impl VALVE_STATE {
+ pub fn equal(&self, other: &VALVE_STATE) -> bool { *self == *other }
+ pub fn unequal(&self, other: &VALVE_STATE) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::valve_open,
+ 1 => Self::valve_closed,
+ _ => panic!("VALVE_STATE index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<2> for VALVE_STATE {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_VALVE_STATE = BSet<VALVE_STATE, 2>;
+//set_enum_declaration done
+
+//relation_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum POSITION_X_DOOR_STATE {
+ #[default]
+ fr_open = 0,
+ fr_closed = 1,
+ fr_door_moving = 2,
+ lt_open = 3,
+ lt_closed = 4,
+ lt_door_moving = 5,
+ rt_open = 6,
+ rt_closed = 7,
+ rt_door_moving = 8
+}
+type rel_POSITION_X_DOOR_STATE = BRelation<POSITION, { POSITION::VARIANTS }, DOOR_STATE, { DOOR_STATE::VARIANTS }, 9>;
+//relation_declaration done
+
+
+
+
+
+
+
+//relation_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum POSITION_X_GEAR_STATE {
+ #[default]
+ fr_retracted = 0,
+ fr_extended = 1,
+ fr_gear_moving = 2,
+ lt_retracted = 3,
+ lt_extended = 4,
+ lt_gear_moving = 5,
+ rt_retracted = 6,
+ rt_extended = 7,
+ rt_gear_moving = 8
+}
+type rel_POSITION_X_GEAR_STATE = BRelation<POSITION, { POSITION::VARIANTS }, GEAR_STATE, { GEAR_STATE::VARIANTS }, 9>;
+//relation_declaration done
+
+
+
+
+
+
+
+//enum_set_declaration start
+#[derive(Default, Debug, Clone, Copy)]
+// each enum value corresponds to one BSet
+pub enum SetGEAR_STATE {
+ #[default]
+ SET_SET__TES_TES = 0,
+ SET_SET_retracted_TES_TES = 1,
+ SET_SET_extended_TES_TES = 2,
+ SET_SET_retracted__extended_TES_TES = 3,
+ SET_SET_gear_moving_TES_TES = 4,
+ SET_SET_retracted__gear_moving_TES_TES = 5,
+ SET_SET_extended__gear_moving_TES_TES = 6,
+ SET_SET_retracted__extended__gear_moving_TES_TES = 7
+}
+type set_SetGEAR_STATE = BSet<set_GEAR_STATE, 8>;
+
+impl PowSetItem<8, 3> for GEAR_STATE {
+ type SetRepr = SetGEAR_STATE;
+ fn arr_to_idx(set: [bool; 3]) -> usize {
+ match set {
+ [false, false, false] => 0,
+ [true, false, false] => 1,
+ [false, true, false] => 2,
+ [true, true, false] => 3,
+ [false, false, true] => 4,
+ [true, false, true] => 5,
+ [false, true, true] => 6,
+ [true, true, true] => 7,
+ _ => panic!("Attempting to convert non-existing set to index!") // only happens if this is a const-set and code-generation missed a necessary value
+ }
+ }
+ fn idx_to_arr(idx: usize) -> [bool; 3] {
+ match idx {
+ 0 => [false, false, false],
+ 1 => [true, false, false],
+ 2 => [false, true, false],
+ 3 => [true, true, false],
+ 4 => [false, false, true],
+ 5 => [true, false, true],
+ 6 => [false, true, true],
+ 7 => [true, true, true],
+ _ => panic!("SetGEAR_STATE index out of range! {:?}", idx)
+ }
+ }
+}
+impl SetGEAR_STATE {
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::SET_SET__TES_TES,
+ 1 => Self::SET_SET_retracted_TES_TES,
+ 2 => Self::SET_SET_extended_TES_TES,
+ 3 => Self::SET_SET_retracted__extended_TES_TES,
+ 4 => Self::SET_SET_gear_moving_TES_TES,
+ 5 => Self::SET_SET_retracted__gear_moving_TES_TES,
+ 6 => Self::SET_SET_extended__gear_moving_TES_TES,
+ 7 => Self::SET_SET_retracted__extended__gear_moving_TES_TES,
+ _ => panic!("SetGEAR_STATE index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<8> for SetGEAR_STATE {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+//enum_set_declaration done
+
+//enum_set_declaration start
+#[derive(Default, Debug, Clone, Copy)]
+// each enum value corresponds to one BSet
+pub enum SetDOOR_STATE {
+ #[default]
+ SET_SET__TES_TES = 0,
+ SET_SET_open_TES_TES = 1,
+ SET_SET_closed_TES_TES = 2,
+ SET_SET_open__closed_TES_TES = 3,
+ SET_SET_door_moving_TES_TES = 4,
+ SET_SET_open__door_moving_TES_TES = 5,
+ SET_SET_closed__door_moving_TES_TES = 6,
+ SET_SET_open__closed__door_moving_TES_TES = 7
+}
+type set_SetDOOR_STATE = BSet<set_DOOR_STATE, 8>;
+
+impl PowSetItem<8, 3> for DOOR_STATE {
+ type SetRepr = SetDOOR_STATE;
+ fn arr_to_idx(set: [bool; 3]) -> usize {
+ match set {
+ [false, false, false] => 0,
+ [true, false, false] => 1,
+ [false, true, false] => 2,
+ [true, true, false] => 3,
+ [false, false, true] => 4,
+ [true, false, true] => 5,
+ [false, true, true] => 6,
+ [true, true, true] => 7,
+ _ => panic!("Attempting to convert non-existing set to index!") // only happens if this is a const-set and code-generation missed a necessary value
+ }
+ }
+ fn idx_to_arr(idx: usize) -> [bool; 3] {
+ match idx {
+ 0 => [false, false, false],
+ 1 => [true, false, false],
+ 2 => [false, true, false],
+ 3 => [true, true, false],
+ 4 => [false, false, true],
+ 5 => [true, false, true],
+ 6 => [false, true, true],
+ 7 => [true, true, true],
+ _ => panic!("SetDOOR_STATE index out of range! {:?}", idx)
+ }
+ }
+}
+impl SetDOOR_STATE {
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::SET_SET__TES_TES,
+ 1 => Self::SET_SET_open_TES_TES,
+ 2 => Self::SET_SET_closed_TES_TES,
+ 3 => Self::SET_SET_open__closed_TES_TES,
+ 4 => Self::SET_SET_door_moving_TES_TES,
+ 5 => Self::SET_SET_open__door_moving_TES_TES,
+ 6 => Self::SET_SET_closed__door_moving_TES_TES,
+ 7 => Self::SET_SET_open__closed__door_moving_TES_TES,
+ _ => panic!("SetDOOR_STATE index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<8> for SetDOOR_STATE {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+//enum_set_declaration done
+
+//enum_set_declaration start
+#[derive(Default, Debug, Clone, Copy)]
+// each enum value corresponds to one BSet
+pub enum SetPOSITION {
+ #[default]
+ SET_SET__TES_TES = 0,
+ SET_SET_fr_TES_TES = 1,
+ SET_SET_lt_TES_TES = 2,
+ SET_SET_fr__lt_TES_TES = 3,
+ SET_SET_rt_TES_TES = 4,
+ SET_SET_fr__rt_TES_TES = 5,
+ SET_SET_lt__rt_TES_TES = 6,
+ SET_SET_fr__lt__rt_TES_TES = 7
+}
+type set_SetPOSITION = BSet<set_POSITION, 8>;
+
+impl PowSetItem<8, 3> for POSITION {
+ type SetRepr = SetPOSITION;
+ fn arr_to_idx(set: [bool; 3]) -> usize {
+ match set {
+ [false, false, false] => 0,
+ [true, false, false] => 1,
+ [false, true, false] => 2,
+ [true, true, false] => 3,
+ [false, false, true] => 4,
+ [true, false, true] => 5,
+ [false, true, true] => 6,
+ [true, true, true] => 7,
+ _ => panic!("Attempting to convert non-existing set to index!") // only happens if this is a const-set and code-generation missed a necessary value
+ }
+ }
+ fn idx_to_arr(idx: usize) -> [bool; 3] {
+ match idx {
+ 0 => [false, false, false],
+ 1 => [true, false, false],
+ 2 => [false, true, false],
+ 3 => [true, true, false],
+ 4 => [false, false, true],
+ 5 => [true, false, true],
+ 6 => [false, true, true],
+ 7 => [true, true, true],
+ _ => panic!("SetPOSITION index out of range! {:?}", idx)
+ }
+ }
+}
+impl SetPOSITION {
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::SET_SET__TES_TES,
+ 1 => Self::SET_SET_fr_TES_TES,
+ 2 => Self::SET_SET_lt_TES_TES,
+ 3 => Self::SET_SET_fr__lt_TES_TES,
+ 4 => Self::SET_SET_rt_TES_TES,
+ 5 => Self::SET_SET_fr__rt_TES_TES,
+ 6 => Self::SET_SET_lt__rt_TES_TES,
+ 7 => Self::SET_SET_fr__lt__rt_TES_TES,
+ _ => panic!("SetPOSITION index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<8> for SetPOSITION {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+//enum_set_declaration done
+
+#[derive(Derivative)]
+#[derivative(Clone, Default, Debug, Hash, PartialEq, Eq)]
+pub struct LandingGear_R6 {
+ /*declarations*/analogical_switch: SWITCH_STATE,
+ general_EV: BBoolean,
+ general_valve: VALVE_STATE,
+ handle_move: BBoolean,
+ close_EV: BBoolean,
+ extend_EV: BBoolean,
+ open_EV: BBoolean,
+ retract_EV: BBoolean,
+ shock_absorber: PLANE_STATE,
+ valve_close_door: VALVE_STATE,
+ valve_extend_gear: VALVE_STATE,
+ valve_open_door: VALVE_STATE,
+ valve_retract_gear: VALVE_STATE,
+ doors: rel_POSITION_X_DOOR_STATE,
+ gears: rel_POSITION_X_GEAR_STATE,
+ handle: HANDLE_STATE,
+ door: DOOR_STATE,
+ gear: GEAR_STATE,
+ /*sets*//*set_declaration*/_DOOR_STATE: set_DOOR_STATE,
+ /*set_declaration*/_GEAR_STATE: set_GEAR_STATE,
+ /*set_declaration*/_HANDLE_STATE: set_HANDLE_STATE,
+ /*set_declaration*/_POSITION: set_POSITION,
+ /*set_declaration*/_SWITCH_STATE: set_SWITCH_STATE,
+ /*set_declaration*/_PLANE_STATE: set_PLANE_STATE,
+ /*set_declaration*/_VALVE_STATE: set_VALVE_STATE,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_begin_flying: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_land_plane: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_open_valve_door_open: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_close_valve_door_open: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_open_valve_door_close: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_close_valve_door_close: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_open_valve_retract_gear: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_close_valve_retract_gear: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_open_valve_extend_gear: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_close_valve_extend_gear: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_con_stimulate_open_door_valve: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_con_stop_stimulate_open_door_valve: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_con_stimulate_close_door_valve: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_con_stop_stimulate_close_door_valve: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_con_stimulate_retract_gear_valve: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_con_stop_stimulate_retract_gear_valve: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_con_stimulate_extend_gear_valve: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_con_stop_stimulate_extend_gear_valve: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_env_start_retracting_first: Option<HashSet<POSITION>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_env_retract_gear_skip: Option<HashSet<POSITION>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_env_retract_gear_last: Option<HashSet<POSITION>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_env_start_extending: Option<HashSet<POSITION>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_env_extend_gear_last: Option<HashSet<POSITION>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_env_extend_gear_skip: Option<HashSet<POSITION>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_env_start_open_door: Option<HashSet<POSITION>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_env_open_door_last: Option<HashSet<POSITION>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_env_open_door_skip: Option<HashSet<POSITION>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_env_start_close_door: Option<HashSet<POSITION>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_env_close_door: Option<HashSet<POSITION>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_env_close_door_skip: Option<HashSet<POSITION>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_toggle_handle_up: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_toggle_handle_down: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_con_stimulate_general_valve: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_con_stop_stimulate_general_valve: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_evn_open_general_valve: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_evn_close_general_valve: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_env_close_analogical_switch: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_env_open_analogical_switch: Option<bool>,}
+
+
+impl LandingGear_R6 {
+
+ pub fn new() -> LandingGear_R6 {
+ //values: ''
+ let mut m: LandingGear_R6 = Default::default();
+ m.init();
+ return m;
+ }
+ fn init(&mut self) {
+ /*set_initializations*///set_initialization
+ self._DOOR_STATE = bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open, /*enum_call*/DOOR_STATE::closed, /*enum_call*/DOOR_STATE::door_moving];
+ //set_initialization
+ self._GEAR_STATE = bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted, /*enum_call*/GEAR_STATE::extended, /*enum_call*/GEAR_STATE::gear_moving];
+ //set_initialization
+ self._HANDLE_STATE = bset![HANDLE_STATE, /*enum_call*/HANDLE_STATE::up, /*enum_call*/HANDLE_STATE::down];
+ //set_initialization
+ self._POSITION = bset![POSITION, /*enum_call*/POSITION::fr, /*enum_call*/POSITION::lt, /*enum_call*/POSITION::rt];
+ //set_initialization
+ self._SWITCH_STATE = bset![SWITCH_STATE, /*enum_call*/SWITCH_STATE::switch_open, /*enum_call*/SWITCH_STATE::switch_closed];
+ //set_initialization
+ self._PLANE_STATE = bset![PLANE_STATE, /*enum_call*/PLANE_STATE::ground, /*enum_call*/PLANE_STATE::flight];
+ //set_initialization
+ self._VALVE_STATE = bset![VALVE_STATE, /*enum_call*/VALVE_STATE::valve_open, /*enum_call*/VALVE_STATE::valve_closed];
+ /*properties*/
+ /*body*/self.gears = rel_POSITION_X_GEAR_STATE::cartesian_product(&self._POSITION, &bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended]).clone().clone();
+ self.doors = rel_POSITION_X_DOOR_STATE::cartesian_product(&self._POSITION, &bset![DOOR_STATE, /*enum_call*/DOOR_STATE::closed]).clone().clone();
+ self.handle = /*enum_call*/HANDLE_STATE::down;
+ self.valve_extend_gear = /*enum_call*/VALVE_STATE::valve_closed;
+ self.valve_retract_gear = /*enum_call*/VALVE_STATE::valve_closed;
+ self.valve_open_door = /*enum_call*/VALVE_STATE::valve_closed;
+ self.valve_close_door = /*enum_call*/VALVE_STATE::valve_closed;
+ self.open_EV = false;
+ self.close_EV = false;
+ self.retract_EV = false;
+ self.extend_EV = false;
+ self.shock_absorber = /*enum_call*/PLANE_STATE::ground;
+ self.general_EV = false;
+ self.general_valve = /*enum_call*/VALVE_STATE::valve_closed;
+ self.analogical_switch = /*enum_call*/SWITCH_STATE::switch_open;
+ self.handle_move = false;
+ self.gear = /*enum_call*/GEAR_STATE::extended;
+ self.door = /*enum_call*/DOOR_STATE::closed;
+ /*includesInitialization*/
+ }
+
+ pub fn get_analogical_switch(&self) -> SWITCH_STATE {
+ return self.analogical_switch.clone();
+ }
+
+ pub fn get_general_EV(&self) -> BBoolean {
+ return self.general_EV.clone();
+ }
+
+ pub fn get_general_valve(&self) -> VALVE_STATE {
+ return self.general_valve.clone();
+ }
+
+ pub fn get_handle_move(&self) -> BBoolean {
+ return self.handle_move.clone();
+ }
+
+ pub fn get_close_EV(&self) -> BBoolean {
+ return self.close_EV.clone();
+ }
+
+ pub fn get_extend_EV(&self) -> BBoolean {
+ return self.extend_EV.clone();
+ }
+
+ pub fn get_open_EV(&self) -> BBoolean {
+ return self.open_EV.clone();
+ }
+
+ pub fn get_retract_EV(&self) -> BBoolean {
+ return self.retract_EV.clone();
+ }
+
+ pub fn get_shock_absorber(&self) -> PLANE_STATE {
+ return self.shock_absorber.clone();
+ }
+
+ pub fn get_valve_close_door(&self) -> VALVE_STATE {
+ return self.valve_close_door.clone();
+ }
+
+ pub fn get_valve_extend_gear(&self) -> VALVE_STATE {
+ return self.valve_extend_gear.clone();
+ }
+
+ pub fn get_valve_open_door(&self) -> VALVE_STATE {
+ return self.valve_open_door.clone();
+ }
+
+ pub fn get_valve_retract_gear(&self) -> VALVE_STATE {
+ return self.valve_retract_gear.clone();
+ }
+
+ pub fn get_doors(&self) -> rel_POSITION_X_DOOR_STATE {
+ return self.doors.clone();
+ }
+
+ pub fn get_gears(&self) -> rel_POSITION_X_GEAR_STATE {
+ return self.gears.clone();
+ }
+
+ pub fn get_handle(&self) -> HANDLE_STATE {
+ return self.handle.clone();
+ }
+
+ pub fn get_door(&self) -> DOOR_STATE {
+ return self.door.clone();
+ }
+
+ pub fn get_gear(&self) -> GEAR_STATE {
+ return self.gear.clone();
+ }
+
+ pub fn get__DOOR_STATE(&self) -> set_DOOR_STATE {
+ return self._DOOR_STATE.clone();
+ }
+
+ pub fn get__GEAR_STATE(&self) -> set_GEAR_STATE {
+ return self._GEAR_STATE.clone();
+ }
+
+ pub fn get__HANDLE_STATE(&self) -> set_HANDLE_STATE {
+ return self._HANDLE_STATE.clone();
+ }
+
+ pub fn get__POSITION(&self) -> set_POSITION {
+ return self._POSITION.clone();
+ }
+
+ pub fn get__SWITCH_STATE(&self) -> set_SWITCH_STATE {
+ return self._SWITCH_STATE.clone();
+ }
+
+ pub fn get__PLANE_STATE(&self) -> set_PLANE_STATE {
+ return self._PLANE_STATE.clone();
+ }
+
+ pub fn get__VALVE_STATE(&self) -> set_VALVE_STATE {
+ return self._VALVE_STATE.clone();
+ }
+
+ pub fn begin_flying(&mut self) -> () {
+ //select
+ if self.shock_absorber.equal(&/*enum_call*/PLANE_STATE::ground) {
+ self.shock_absorber = /*enum_call*/PLANE_STATE::flight;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn land_plane(&mut self) -> () {
+ //select
+ if self.shock_absorber.equal(&/*enum_call*/PLANE_STATE::flight) {
+ self.shock_absorber = /*enum_call*/PLANE_STATE::ground;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn open_valve_door_open(&mut self) -> () {
+ //select
+ if (self.valve_open_door.equal(&/*enum_call*/VALVE_STATE::valve_closed) && self.open_EV.equal(&true)) {
+ self.valve_open_door = /*enum_call*/VALVE_STATE::valve_open;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn close_valve_door_open(&mut self) -> () {
+ //select
+ if (self.valve_open_door.equal(&/*enum_call*/VALVE_STATE::valve_open) && self.open_EV.equal(&false)) {
+ self.valve_open_door = /*enum_call*/VALVE_STATE::valve_closed;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn open_valve_door_close(&mut self) -> () {
+ //select
+ if (self.valve_close_door.equal(&/*enum_call*/VALVE_STATE::valve_closed) && self.close_EV.equal(&true)) {
+ self.valve_close_door = /*enum_call*/VALVE_STATE::valve_open;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn close_valve_door_close(&mut self) -> () {
+ //select
+ if (self.valve_close_door.equal(&/*enum_call*/VALVE_STATE::valve_open) && self.close_EV.equal(&false)) {
+ self.valve_close_door = /*enum_call*/VALVE_STATE::valve_closed;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn open_valve_retract_gear(&mut self) -> () {
+ //select
+ if (self.valve_retract_gear.equal(&/*enum_call*/VALVE_STATE::valve_closed) && self.retract_EV.equal(&true)) {
+ self.valve_retract_gear = /*enum_call*/VALVE_STATE::valve_open;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn close_valve_retract_gear(&mut self) -> () {
+ //select
+ if (self.valve_retract_gear.equal(&/*enum_call*/VALVE_STATE::valve_open) && self.retract_EV.equal(&false)) {
+ self.valve_retract_gear = /*enum_call*/VALVE_STATE::valve_closed;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn open_valve_extend_gear(&mut self) -> () {
+ //select
+ if (self.valve_extend_gear.equal(&/*enum_call*/VALVE_STATE::valve_closed) && self.extend_EV.equal(&true)) {
+ self.valve_extend_gear = /*enum_call*/VALVE_STATE::valve_open;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn close_valve_extend_gear(&mut self) -> () {
+ //select
+ if (self.valve_extend_gear.equal(&/*enum_call*/VALVE_STATE::valve_open) && self.extend_EV.equal(&false)) {
+ self.valve_extend_gear = /*enum_call*/VALVE_STATE::valve_closed;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn con_stimulate_open_door_valve(&mut self) -> () {
+ //select
+ if (((self.open_EV.equal(&false) && self.close_EV.equal(&false)) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended]).not()) || ((self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted]).not()) && (self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open]) && self.shock_absorber.equal(&/*enum_call*/PLANE_STATE::ground)).not()))) && self.general_EV.equal(&true)) {
+ self.open_EV = true;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn con_stop_stimulate_open_door_valve(&mut self) -> () {
+ //select
+ if ((((self.open_EV.equal(&true) && self.extend_EV.equal(&false)) && self.retract_EV.equal(&false)) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])) || ((self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && (self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted]) || self.shock_absorber.equal(&/*enum_call*/PLANE_STATE::ground))) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open])))) && self.general_EV.equal(&true)) {
+ self.open_EV = false;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn con_stimulate_close_door_valve(&mut self) -> () {
+ //select
+ if ((((((self.close_EV.equal(&false) && self.open_EV.equal(&false)) && self.extend_EV.equal(&false)) && self.retract_EV.equal(&false)) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && (self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted]) || self.shock_absorber.equal(&/*enum_call*/PLANE_STATE::ground))))) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::closed]).not()) && self.general_EV.equal(&true)) {
+ self.close_EV = true;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn con_stop_stimulate_close_door_valve(&mut self) -> () {
+ //select
+ if ((self.close_EV.equal(&true) && (((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::closed])) || ((self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && (self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted]) || self.shock_absorber.equal(&/*enum_call*/PLANE_STATE::ground))) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::closed])))) && self.general_EV.equal(&true)) {
+ self.close_EV = false;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn con_stimulate_retract_gear_valve(&mut self) -> () {
+ //select
+ if (((((((self.retract_EV.equal(&false) && self.extend_EV.equal(&false)) && self.open_EV.equal(&true)) && self.handle.equal(&/*enum_call*/HANDLE_STATE::up)) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted]).not()) && self.shock_absorber.equal(&/*enum_call*/PLANE_STATE::flight)) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open])) && self.general_EV.equal(&true)) {
+ self.retract_EV = true;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn con_stop_stimulate_retract_gear_valve(&mut self) -> () {
+ //select
+ if ((self.retract_EV.equal(&true) && (self.handle.equal(&/*enum_call*/HANDLE_STATE::down) || self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted]))) && self.general_EV.equal(&true)) {
+ self.retract_EV = false;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn con_stimulate_extend_gear_valve(&mut self) -> () {
+ //select
+ if ((((((self.extend_EV.equal(&false) && self.retract_EV.equal(&false)) && self.open_EV.equal(&true)) && self.handle.equal(&/*enum_call*/HANDLE_STATE::down)) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended]).not()) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open])) && self.general_EV.equal(&true)) {
+ self.extend_EV = true;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn con_stop_stimulate_extend_gear_valve(&mut self) -> () {
+ //select
+ if ((self.extend_EV.equal(&true) && (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) || self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended]))) && self.general_EV.equal(&true)) {
+ self.extend_EV = false;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn env_start_retracting_first(&mut self, mut gr: POSITION) -> () {
+ //select
+ if (((((((self.gears.domain().elementOf(&gr) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open])) && self.handle.equal(&/*enum_call*/HANDLE_STATE::up)) && self.gears.functionCall(&gr).equal(&/*enum_call*/GEAR_STATE::extended)) && self.valve_retract_gear.equal(&/*enum_call*/VALVE_STATE::valve_open)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) && bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended, /*enum_call*/GEAR_STATE::gear_moving].elementOf(&self.gear)) && self.door.equal(&/*enum_call*/DOOR_STATE::open)) {
+ let mut _ld_gears = self.gears.clone();
+ self.gears = _ld_gears._override(&brel![rel_POSITION_X_GEAR_STATE, (gr.clone(), /*enum_call*/GEAR_STATE::gear_moving.clone())]).clone().clone();
+ self.gear = /*enum_call*/GEAR_STATE::gear_moving;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn env_retract_gear_skip(&mut self, mut gr: POSITION) -> () {
+ //select
+ if (((((self.gears.domain().elementOf(&gr) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open])) && self.gears.relationImage(&self._POSITION.difference(&bset![POSITION, gr])).unequal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted])) && self.handle.equal(&/*enum_call*/HANDLE_STATE::up)) && self.gears.functionCall(&gr).equal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) {
+ self.gears = self.gears._override(&brel![rel_POSITION_X_GEAR_STATE, (gr.clone(), /*enum_call*/GEAR_STATE::retracted.clone())]).clone().clone();
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn env_retract_gear_last(&mut self, mut gr: POSITION) -> () {
+ //select
+ if (((((((self.gears.domain().elementOf(&gr) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open])) && self.gears.relationImage(&self._POSITION.difference(&bset![POSITION, gr])).equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted])) && self.handle.equal(&/*enum_call*/HANDLE_STATE::up)) && self.gears.functionCall(&gr).equal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) && self.gear.equal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.door.equal(&/*enum_call*/DOOR_STATE::open)) {
+ let mut _ld_gears = self.gears.clone();
+ self.gears = _ld_gears._override(&brel![rel_POSITION_X_GEAR_STATE, (gr.clone(), /*enum_call*/GEAR_STATE::retracted.clone())]).clone().clone();
+ self.gear = /*enum_call*/GEAR_STATE::retracted;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn env_start_extending(&mut self, mut gr: POSITION) -> () {
+ //select
+ if (((((((self.gears.domain().elementOf(&gr) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open])) && self.handle.equal(&/*enum_call*/HANDLE_STATE::down)) && self.gears.functionCall(&gr).equal(&/*enum_call*/GEAR_STATE::retracted)) && self.valve_extend_gear.equal(&/*enum_call*/VALVE_STATE::valve_open)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) && bset![GEAR_STATE, /*enum_call*/GEAR_STATE::gear_moving, /*enum_call*/GEAR_STATE::retracted].elementOf(&self.gear)) && self.door.equal(&/*enum_call*/DOOR_STATE::open)) {
+ let mut _ld_gears = self.gears.clone();
+ self.gears = _ld_gears._override(&brel![rel_POSITION_X_GEAR_STATE, (gr.clone(), /*enum_call*/GEAR_STATE::gear_moving.clone())]).clone().clone();
+ self.gear = /*enum_call*/GEAR_STATE::gear_moving;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn env_extend_gear_last(&mut self, mut gr: POSITION) -> () {
+ //select
+ if (((((((self.gears.domain().elementOf(&gr) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open])) && self.handle.equal(&/*enum_call*/HANDLE_STATE::down)) && self.gears.relationImage(&self._POSITION.difference(&bset![POSITION, gr])).equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])) && self.gears.functionCall(&gr).equal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) && self.gear.equal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.door.equal(&/*enum_call*/DOOR_STATE::open)) {
+ let mut _ld_gears = self.gears.clone();
+ self.gears = _ld_gears._override(&brel![rel_POSITION_X_GEAR_STATE, (gr.clone(), /*enum_call*/GEAR_STATE::extended.clone())]).clone().clone();
+ self.gear = /*enum_call*/GEAR_STATE::extended;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn env_extend_gear_skip(&mut self, mut gr: POSITION) -> () {
+ //select
+ if (((((self.gears.domain().elementOf(&gr) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open])) && self.handle.equal(&/*enum_call*/HANDLE_STATE::down)) && self.gears.relationImage(&self._POSITION.difference(&bset![POSITION, gr])).unequal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])) && self.gears.functionCall(&gr).equal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) {
+ self.gears = self.gears._override(&brel![rel_POSITION_X_GEAR_STATE, (gr.clone(), /*enum_call*/GEAR_STATE::extended.clone())]).clone().clone();
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn env_start_open_door(&mut self, mut gr: POSITION) -> () {
+ //select
+ if (((((((((self.gears.domain().elementOf(&gr) && self.doors.functionCall(&gr).equal(&/*enum_call*/DOOR_STATE::closed)) && self.gears.functionCall(&gr).unequal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.gears.range().notElementOf(&/*enum_call*/GEAR_STATE::gear_moving)) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted])) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])))) && self.valve_open_door.equal(&/*enum_call*/VALVE_STATE::valve_open)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) && bset![DOOR_STATE, /*enum_call*/DOOR_STATE::closed, /*enum_call*/DOOR_STATE::door_moving].elementOf(&self.door)) && self.gear.unequal(&/*enum_call*/GEAR_STATE::gear_moving)) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gear.equal(&/*enum_call*/GEAR_STATE::retracted)) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && self.gear.equal(&/*enum_call*/GEAR_STATE::extended)))) {
+ let mut _ld_doors = self.doors.clone();
+ self.doors = _ld_doors._override(&brel![rel_POSITION_X_DOOR_STATE, (gr.clone(), /*enum_call*/DOOR_STATE::door_moving.clone())]).clone().clone();
+ self.door = /*enum_call*/DOOR_STATE::door_moving;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn env_open_door_last(&mut self, mut gr: POSITION) -> () {
+ //select
+ if ((((((((((self.gears.domain().elementOf(&gr) && self.doors.functionCall(&gr).equal(&/*enum_call*/DOOR_STATE::door_moving)) && self.gears.functionCall(&gr).unequal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.gears.range().notElementOf(&/*enum_call*/GEAR_STATE::gear_moving)) && self.doors.relationImage(&self._POSITION.difference(&bset![POSITION, gr])).equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open])) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted])) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])))) && self.valve_open_door.equal(&/*enum_call*/VALVE_STATE::valve_open)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) && self.door.equal(&/*enum_call*/DOOR_STATE::door_moving)) && self.gear.unequal(&/*enum_call*/GEAR_STATE::gear_moving)) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gear.equal(&/*enum_call*/GEAR_STATE::retracted)) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && self.gear.equal(&/*enum_call*/GEAR_STATE::extended)))) {
+ let mut _ld_doors = self.doors.clone();
+ self.doors = _ld_doors._override(&brel![rel_POSITION_X_DOOR_STATE, (gr.clone(), /*enum_call*/DOOR_STATE::open.clone())]).clone().clone();
+ self.door = /*enum_call*/DOOR_STATE::open;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn env_open_door_skip(&mut self, mut gr: POSITION) -> () {
+ //select
+ if (((((((self.gears.domain().elementOf(&gr) && self.doors.functionCall(&gr).equal(&/*enum_call*/DOOR_STATE::door_moving)) && self.gears.functionCall(&gr).unequal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.gears.range().notElementOf(&/*enum_call*/GEAR_STATE::gear_moving)) && self.doors.relationImage(&self._POSITION.difference(&bset![POSITION, gr])).unequal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open])) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted])) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])))) && self.valve_open_door.equal(&/*enum_call*/VALVE_STATE::valve_open)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) {
+ self.doors = self.doors._override(&brel![rel_POSITION_X_DOOR_STATE, (gr.clone(), /*enum_call*/DOOR_STATE::open.clone())]).clone().clone();
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn env_start_close_door(&mut self, mut gr: POSITION) -> () {
+ //select
+ if ((((((((self.gears.domain().elementOf(&gr) && self.doors.functionCall(&gr).equal(&/*enum_call*/DOOR_STATE::open)) && self.gears.functionCall(&gr).unequal(&/*enum_call*/GEAR_STATE::gear_moving)) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && (self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted]) || self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended]))) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])))) && self.valve_close_door.equal(&/*enum_call*/VALVE_STATE::valve_open)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) && bset![DOOR_STATE, /*enum_call*/DOOR_STATE::door_moving, /*enum_call*/DOOR_STATE::open].elementOf(&self.door)) && self.gear.unequal(&/*enum_call*/GEAR_STATE::gear_moving)) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gear.equal(&/*enum_call*/GEAR_STATE::extended)) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended, /*enum_call*/GEAR_STATE::retracted].elementOf(&self.gear)))) {
+ let mut _ld_doors = self.doors.clone();
+ self.doors = _ld_doors._override(&brel![rel_POSITION_X_DOOR_STATE, (gr.clone(), /*enum_call*/DOOR_STATE::door_moving.clone())]).clone().clone();
+ self.door = /*enum_call*/DOOR_STATE::door_moving;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn env_close_door(&mut self, mut gr: POSITION) -> () {
+ //select
+ if (((((((((((self.gears.domain().elementOf(&gr) && self.doors.functionCall(&gr).equal(&/*enum_call*/DOOR_STATE::door_moving)) && self.gears.functionCall(&gr).unequal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.gears.range().notElementOf(&/*enum_call*/GEAR_STATE::gear_moving)) && self.doors.relationImage(&self._POSITION.difference(&bset![POSITION, gr])).equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::closed])) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && (self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted]) || self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended]))) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])))) && self.valve_close_door.equal(&/*enum_call*/VALVE_STATE::valve_open)) && (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])).implies(|| self.shock_absorber.equal(&/*enum_call*/PLANE_STATE::ground))) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) && self.door.equal(&/*enum_call*/DOOR_STATE::door_moving)) && self.gear.unequal(&/*enum_call*/GEAR_STATE::gear_moving)) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gear.equal(&/*enum_call*/GEAR_STATE::extended)) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended, /*enum_call*/GEAR_STATE::retracted].elementOf(&self.gear)))) {
+ let mut _ld_doors = self.doors.clone();
+ self.doors = _ld_doors._override(&brel![rel_POSITION_X_DOOR_STATE, (gr.clone(), /*enum_call*/DOOR_STATE::closed.clone())]).clone().clone();
+ self.door = /*enum_call*/DOOR_STATE::closed;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn env_close_door_skip(&mut self, mut gr: POSITION) -> () {
+ //select
+ if ((((((((self.gears.domain().elementOf(&gr) && self.doors.functionCall(&gr).equal(&/*enum_call*/DOOR_STATE::door_moving)) && self.gears.functionCall(&gr).unequal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.gears.range().notElementOf(&/*enum_call*/GEAR_STATE::gear_moving)) && self.doors.relationImage(&self._POSITION.difference(&bset![POSITION, gr])).unequal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::closed])) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && (self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted]) || self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended]))) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])))) && self.valve_close_door.equal(&/*enum_call*/VALVE_STATE::valve_open)) && (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])).implies(|| self.shock_absorber.equal(&/*enum_call*/PLANE_STATE::ground))) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) {
+ self.doors = self.doors._override(&brel![rel_POSITION_X_DOOR_STATE, (gr.clone(), /*enum_call*/DOOR_STATE::closed.clone())]).clone().clone();
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn toggle_handle_up(&mut self) -> () {
+ //select
+ if self.handle.equal(&/*enum_call*/HANDLE_STATE::down) {
+ self.handle = /*enum_call*/HANDLE_STATE::up;
+ self.handle_move = true;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn toggle_handle_down(&mut self) -> () {
+ //select
+ if self.handle.equal(&/*enum_call*/HANDLE_STATE::up) {
+ self.handle = /*enum_call*/HANDLE_STATE::down;
+ self.handle_move = true;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn con_stimulate_general_valve(&mut self) -> () {
+ //select
+ if (self.general_EV.equal(&false) && self.handle_move.equal(&true)) {
+ self.general_EV = true;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn con_stop_stimulate_general_valve(&mut self) -> () {
+ //select
+ if ((((((self.general_EV.equal(&true) && self.open_EV.equal(&false)) && self.close_EV.equal(&false)) && self.retract_EV.equal(&false)) && self.extend_EV.equal(&false)) && self.close_EV.equal(&false)) && (((((self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted])) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::closed])) && self.open_EV.equal(&false)) || (((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::closed])) && self.open_EV.equal(&false))) || (((self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::closed])) && self.open_EV.equal(&false)))) {
+ self.general_EV = false;
+ self.handle_move = false;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn evn_open_general_valve(&mut self) -> () {
+ //select
+ if ((self.general_EV.equal(&true) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_closed)) && self.analogical_switch.equal(&/*enum_call*/SWITCH_STATE::switch_closed)) {
+ self.general_valve = /*enum_call*/VALVE_STATE::valve_open;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn evn_close_general_valve(&mut self) -> () {
+ //select
+ if ((self.general_EV.equal(&false) || self.analogical_switch.equal(&/*enum_call*/SWITCH_STATE::switch_open)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) {
+ self.general_valve = /*enum_call*/VALVE_STATE::valve_closed;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn env_close_analogical_switch(&mut self) -> () {
+ //select
+ if (self.analogical_switch.equal(&/*enum_call*/SWITCH_STATE::switch_open) && self.handle_move.equal(&true)) {
+ self.analogical_switch = /*enum_call*/SWITCH_STATE::switch_closed;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn env_open_analogical_switch(&mut self) -> () {
+ //select
+ if self.analogical_switch.equal(&/*enum_call*/SWITCH_STATE::switch_closed) {
+ self.analogical_switch = /*enum_call*/SWITCH_STATE::switch_open;
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ }
+
+ pub fn _tr_begin_flying(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_begin_flying.is_none() {
+ let mut __tmp__val__ = self.shock_absorber.equal(&/*enum_call*/PLANE_STATE::ground);
+ self._tr_cache_begin_flying = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_begin_flying.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_land_plane(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_land_plane.is_none() {
+ let mut __tmp__val__ = self.shock_absorber.equal(&/*enum_call*/PLANE_STATE::flight);
+ self._tr_cache_land_plane = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_land_plane.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_open_valve_door_open(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_open_valve_door_open.is_none() {
+ let mut __tmp__val__ = (self.valve_open_door.equal(&/*enum_call*/VALVE_STATE::valve_closed) && self.open_EV.equal(&true));
+ self._tr_cache_open_valve_door_open = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_open_valve_door_open.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_close_valve_door_open(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_close_valve_door_open.is_none() {
+ let mut __tmp__val__ = (self.valve_open_door.equal(&/*enum_call*/VALVE_STATE::valve_open) && self.open_EV.equal(&false));
+ self._tr_cache_close_valve_door_open = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_close_valve_door_open.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_open_valve_door_close(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_open_valve_door_close.is_none() {
+ let mut __tmp__val__ = (self.valve_close_door.equal(&/*enum_call*/VALVE_STATE::valve_closed) && self.close_EV.equal(&true));
+ self._tr_cache_open_valve_door_close = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_open_valve_door_close.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_close_valve_door_close(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_close_valve_door_close.is_none() {
+ let mut __tmp__val__ = (self.valve_close_door.equal(&/*enum_call*/VALVE_STATE::valve_open) && self.close_EV.equal(&false));
+ self._tr_cache_close_valve_door_close = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_close_valve_door_close.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_open_valve_retract_gear(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_open_valve_retract_gear.is_none() {
+ let mut __tmp__val__ = (self.valve_retract_gear.equal(&/*enum_call*/VALVE_STATE::valve_closed) && self.retract_EV.equal(&true));
+ self._tr_cache_open_valve_retract_gear = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_open_valve_retract_gear.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_close_valve_retract_gear(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_close_valve_retract_gear.is_none() {
+ let mut __tmp__val__ = (self.valve_retract_gear.equal(&/*enum_call*/VALVE_STATE::valve_open) && self.retract_EV.equal(&false));
+ self._tr_cache_close_valve_retract_gear = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_close_valve_retract_gear.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_open_valve_extend_gear(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_open_valve_extend_gear.is_none() {
+ let mut __tmp__val__ = (self.valve_extend_gear.equal(&/*enum_call*/VALVE_STATE::valve_closed) && self.extend_EV.equal(&true));
+ self._tr_cache_open_valve_extend_gear = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_open_valve_extend_gear.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_close_valve_extend_gear(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_close_valve_extend_gear.is_none() {
+ let mut __tmp__val__ = (self.valve_extend_gear.equal(&/*enum_call*/VALVE_STATE::valve_open) && self.extend_EV.equal(&false));
+ self._tr_cache_close_valve_extend_gear = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_close_valve_extend_gear.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_con_stimulate_open_door_valve(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_con_stimulate_open_door_valve.is_none() {
+ let mut __tmp__val__ = (((self.open_EV.equal(&false) && self.close_EV.equal(&false)) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended]).not()) || ((self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted]).not()) && (self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open]) && self.shock_absorber.equal(&/*enum_call*/PLANE_STATE::ground)).not()))) && self.general_EV.equal(&true));
+ self._tr_cache_con_stimulate_open_door_valve = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_con_stimulate_open_door_valve.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_con_stop_stimulate_open_door_valve(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_con_stop_stimulate_open_door_valve.is_none() {
+ let mut __tmp__val__ = ((((self.open_EV.equal(&true) && self.extend_EV.equal(&false)) && self.retract_EV.equal(&false)) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])) || ((self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && (self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted]) || self.shock_absorber.equal(&/*enum_call*/PLANE_STATE::ground))) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open])))) && self.general_EV.equal(&true));
+ self._tr_cache_con_stop_stimulate_open_door_valve = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_con_stop_stimulate_open_door_valve.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_con_stimulate_close_door_valve(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_con_stimulate_close_door_valve.is_none() {
+ let mut __tmp__val__ = ((((((self.close_EV.equal(&false) && self.open_EV.equal(&false)) && self.extend_EV.equal(&false)) && self.retract_EV.equal(&false)) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && (self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted]) || self.shock_absorber.equal(&/*enum_call*/PLANE_STATE::ground))))) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::closed]).not()) && self.general_EV.equal(&true));
+ self._tr_cache_con_stimulate_close_door_valve = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_con_stimulate_close_door_valve.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_con_stop_stimulate_close_door_valve(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_con_stop_stimulate_close_door_valve.is_none() {
+ let mut __tmp__val__ = ((self.close_EV.equal(&true) && (((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::closed])) || ((self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && (self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted]) || self.shock_absorber.equal(&/*enum_call*/PLANE_STATE::ground))) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::closed])))) && self.general_EV.equal(&true));
+ self._tr_cache_con_stop_stimulate_close_door_valve = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_con_stop_stimulate_close_door_valve.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_con_stimulate_retract_gear_valve(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_con_stimulate_retract_gear_valve.is_none() {
+ let mut __tmp__val__ = (((((((self.retract_EV.equal(&false) && self.extend_EV.equal(&false)) && self.open_EV.equal(&true)) && self.handle.equal(&/*enum_call*/HANDLE_STATE::up)) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted]).not()) && self.shock_absorber.equal(&/*enum_call*/PLANE_STATE::flight)) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open])) && self.general_EV.equal(&true));
+ self._tr_cache_con_stimulate_retract_gear_valve = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_con_stimulate_retract_gear_valve.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_con_stop_stimulate_retract_gear_valve(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_con_stop_stimulate_retract_gear_valve.is_none() {
+ let mut __tmp__val__ = ((self.retract_EV.equal(&true) && (self.handle.equal(&/*enum_call*/HANDLE_STATE::down) || self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted]))) && self.general_EV.equal(&true));
+ self._tr_cache_con_stop_stimulate_retract_gear_valve = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_con_stop_stimulate_retract_gear_valve.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_con_stimulate_extend_gear_valve(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_con_stimulate_extend_gear_valve.is_none() {
+ let mut __tmp__val__ = ((((((self.extend_EV.equal(&false) && self.retract_EV.equal(&false)) && self.open_EV.equal(&true)) && self.handle.equal(&/*enum_call*/HANDLE_STATE::down)) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended]).not()) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open])) && self.general_EV.equal(&true));
+ self._tr_cache_con_stimulate_extend_gear_valve = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_con_stimulate_extend_gear_valve.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_con_stop_stimulate_extend_gear_valve(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_con_stop_stimulate_extend_gear_valve.is_none() {
+ let mut __tmp__val__ = ((self.extend_EV.equal(&true) && (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) || self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended]))) && self.general_EV.equal(&true));
+ self._tr_cache_con_stop_stimulate_extend_gear_valve = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_con_stop_stimulate_extend_gear_valve.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_env_start_retracting_first(&mut self, is_caching: bool) -> HashSet<POSITION> {
+ //transition
+ if !is_caching || self._tr_cache_env_start_retracting_first.is_none() {
+ let mut _ic_set_18: HashSet<POSITION> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_gr_1 in self.gears.domain().clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if ((((((self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open]) && self.handle.equal(&/*enum_call*/HANDLE_STATE::up)) && self.gears.functionCall(&_ic_gr_1).equal(&/*enum_call*/GEAR_STATE::extended)) && self.valve_retract_gear.equal(&/*enum_call*/VALVE_STATE::valve_open)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) && bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended, /*enum_call*/GEAR_STATE::gear_moving].elementOf(&self.gear)) && self.door.equal(&/*enum_call*/DOOR_STATE::open)) {
+ _ic_set_18.insert(_ic_gr_1);
+ }
+
+ }
+ self._tr_cache_env_start_retracting_first = Option::Some(_ic_set_18.clone());
+ return _ic_set_18;
+ } else {
+ return self._tr_cache_env_start_retracting_first.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_env_retract_gear_skip(&mut self, is_caching: bool) -> HashSet<POSITION> {
+ //transition
+ if !is_caching || self._tr_cache_env_retract_gear_skip.is_none() {
+ let mut _ic_set_19: HashSet<POSITION> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_gr_1 in self.gears.domain().clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if ((((self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open]) && self.gears.relationImage(&self._POSITION.difference(&bset![POSITION, _ic_gr_1])).unequal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted])) && self.handle.equal(&/*enum_call*/HANDLE_STATE::up)) && self.gears.functionCall(&_ic_gr_1).equal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) {
+ _ic_set_19.insert(_ic_gr_1);
+ }
+
+ }
+ self._tr_cache_env_retract_gear_skip = Option::Some(_ic_set_19.clone());
+ return _ic_set_19;
+ } else {
+ return self._tr_cache_env_retract_gear_skip.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_env_retract_gear_last(&mut self, is_caching: bool) -> HashSet<POSITION> {
+ //transition
+ if !is_caching || self._tr_cache_env_retract_gear_last.is_none() {
+ let mut _ic_set_20: HashSet<POSITION> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_gr_1 in self.gears.domain().clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if ((((((self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open]) && self.gears.relationImage(&self._POSITION.difference(&bset![POSITION, _ic_gr_1])).equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted])) && self.handle.equal(&/*enum_call*/HANDLE_STATE::up)) && self.gears.functionCall(&_ic_gr_1).equal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) && self.gear.equal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.door.equal(&/*enum_call*/DOOR_STATE::open)) {
+ _ic_set_20.insert(_ic_gr_1);
+ }
+
+ }
+ self._tr_cache_env_retract_gear_last = Option::Some(_ic_set_20.clone());
+ return _ic_set_20;
+ } else {
+ return self._tr_cache_env_retract_gear_last.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_env_start_extending(&mut self, is_caching: bool) -> HashSet<POSITION> {
+ //transition
+ if !is_caching || self._tr_cache_env_start_extending.is_none() {
+ let mut _ic_set_21: HashSet<POSITION> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_gr_1 in self.gears.domain().clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if ((((((self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open]) && self.handle.equal(&/*enum_call*/HANDLE_STATE::down)) && self.gears.functionCall(&_ic_gr_1).equal(&/*enum_call*/GEAR_STATE::retracted)) && self.valve_extend_gear.equal(&/*enum_call*/VALVE_STATE::valve_open)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) && bset![GEAR_STATE, /*enum_call*/GEAR_STATE::gear_moving, /*enum_call*/GEAR_STATE::retracted].elementOf(&self.gear)) && self.door.equal(&/*enum_call*/DOOR_STATE::open)) {
+ _ic_set_21.insert(_ic_gr_1);
+ }
+
+ }
+ self._tr_cache_env_start_extending = Option::Some(_ic_set_21.clone());
+ return _ic_set_21;
+ } else {
+ return self._tr_cache_env_start_extending.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_env_extend_gear_last(&mut self, is_caching: bool) -> HashSet<POSITION> {
+ //transition
+ if !is_caching || self._tr_cache_env_extend_gear_last.is_none() {
+ let mut _ic_set_22: HashSet<POSITION> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_gr_1 in self.gears.domain().clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if ((((((self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open]) && self.handle.equal(&/*enum_call*/HANDLE_STATE::down)) && self.gears.relationImage(&self._POSITION.difference(&bset![POSITION, _ic_gr_1])).equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])) && self.gears.functionCall(&_ic_gr_1).equal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) && self.gear.equal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.door.equal(&/*enum_call*/DOOR_STATE::open)) {
+ _ic_set_22.insert(_ic_gr_1);
+ }
+
+ }
+ self._tr_cache_env_extend_gear_last = Option::Some(_ic_set_22.clone());
+ return _ic_set_22;
+ } else {
+ return self._tr_cache_env_extend_gear_last.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_env_extend_gear_skip(&mut self, is_caching: bool) -> HashSet<POSITION> {
+ //transition
+ if !is_caching || self._tr_cache_env_extend_gear_skip.is_none() {
+ let mut _ic_set_23: HashSet<POSITION> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_gr_1 in self.gears.domain().clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if ((((self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open]) && self.handle.equal(&/*enum_call*/HANDLE_STATE::down)) && self.gears.relationImage(&self._POSITION.difference(&bset![POSITION, _ic_gr_1])).unequal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])) && self.gears.functionCall(&_ic_gr_1).equal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) {
+ _ic_set_23.insert(_ic_gr_1);
+ }
+
+ }
+ self._tr_cache_env_extend_gear_skip = Option::Some(_ic_set_23.clone());
+ return _ic_set_23;
+ } else {
+ return self._tr_cache_env_extend_gear_skip.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_env_start_open_door(&mut self, is_caching: bool) -> HashSet<POSITION> {
+ //transition
+ if !is_caching || self._tr_cache_env_start_open_door.is_none() {
+ let mut _ic_set_24: HashSet<POSITION> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_gr_1 in self.gears.domain().clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if ((((((((self.doors.functionCall(&_ic_gr_1).equal(&/*enum_call*/DOOR_STATE::closed) && self.gears.functionCall(&_ic_gr_1).unequal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.gears.range().notElementOf(&/*enum_call*/GEAR_STATE::gear_moving)) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted])) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])))) && self.valve_open_door.equal(&/*enum_call*/VALVE_STATE::valve_open)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) && bset![DOOR_STATE, /*enum_call*/DOOR_STATE::closed, /*enum_call*/DOOR_STATE::door_moving].elementOf(&self.door)) && self.gear.unequal(&/*enum_call*/GEAR_STATE::gear_moving)) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gear.equal(&/*enum_call*/GEAR_STATE::retracted)) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && self.gear.equal(&/*enum_call*/GEAR_STATE::extended)))) {
+ _ic_set_24.insert(_ic_gr_1);
+ }
+
+ }
+ self._tr_cache_env_start_open_door = Option::Some(_ic_set_24.clone());
+ return _ic_set_24;
+ } else {
+ return self._tr_cache_env_start_open_door.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_env_open_door_last(&mut self, is_caching: bool) -> HashSet<POSITION> {
+ //transition
+ if !is_caching || self._tr_cache_env_open_door_last.is_none() {
+ let mut _ic_set_25: HashSet<POSITION> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_gr_1 in self.gears.domain().clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if (((((((((self.doors.functionCall(&_ic_gr_1).equal(&/*enum_call*/DOOR_STATE::door_moving) && self.gears.functionCall(&_ic_gr_1).unequal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.gears.range().notElementOf(&/*enum_call*/GEAR_STATE::gear_moving)) && self.doors.relationImage(&self._POSITION.difference(&bset![POSITION, _ic_gr_1])).equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open])) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted])) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])))) && self.valve_open_door.equal(&/*enum_call*/VALVE_STATE::valve_open)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) && self.door.equal(&/*enum_call*/DOOR_STATE::door_moving)) && self.gear.unequal(&/*enum_call*/GEAR_STATE::gear_moving)) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gear.equal(&/*enum_call*/GEAR_STATE::retracted)) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && self.gear.equal(&/*enum_call*/GEAR_STATE::extended)))) {
+ _ic_set_25.insert(_ic_gr_1);
+ }
+
+ }
+ self._tr_cache_env_open_door_last = Option::Some(_ic_set_25.clone());
+ return _ic_set_25;
+ } else {
+ return self._tr_cache_env_open_door_last.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_env_open_door_skip(&mut self, is_caching: bool) -> HashSet<POSITION> {
+ //transition
+ if !is_caching || self._tr_cache_env_open_door_skip.is_none() {
+ let mut _ic_set_26: HashSet<POSITION> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_gr_1 in self.gears.domain().clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if ((((((self.doors.functionCall(&_ic_gr_1).equal(&/*enum_call*/DOOR_STATE::door_moving) && self.gears.functionCall(&_ic_gr_1).unequal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.gears.range().notElementOf(&/*enum_call*/GEAR_STATE::gear_moving)) && self.doors.relationImage(&self._POSITION.difference(&bset![POSITION, _ic_gr_1])).unequal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open])) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted])) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])))) && self.valve_open_door.equal(&/*enum_call*/VALVE_STATE::valve_open)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) {
+ _ic_set_26.insert(_ic_gr_1);
+ }
+
+ }
+ self._tr_cache_env_open_door_skip = Option::Some(_ic_set_26.clone());
+ return _ic_set_26;
+ } else {
+ return self._tr_cache_env_open_door_skip.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_env_start_close_door(&mut self, is_caching: bool) -> HashSet<POSITION> {
+ //transition
+ if !is_caching || self._tr_cache_env_start_close_door.is_none() {
+ let mut _ic_set_27: HashSet<POSITION> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_gr_1 in self.gears.domain().clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if (((((((self.doors.functionCall(&_ic_gr_1).equal(&/*enum_call*/DOOR_STATE::open) && self.gears.functionCall(&_ic_gr_1).unequal(&/*enum_call*/GEAR_STATE::gear_moving)) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && (self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted]) || self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended]))) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])))) && self.valve_close_door.equal(&/*enum_call*/VALVE_STATE::valve_open)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) && bset![DOOR_STATE, /*enum_call*/DOOR_STATE::door_moving, /*enum_call*/DOOR_STATE::open].elementOf(&self.door)) && self.gear.unequal(&/*enum_call*/GEAR_STATE::gear_moving)) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gear.equal(&/*enum_call*/GEAR_STATE::extended)) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended, /*enum_call*/GEAR_STATE::retracted].elementOf(&self.gear)))) {
+ _ic_set_27.insert(_ic_gr_1);
+ }
+
+ }
+ self._tr_cache_env_start_close_door = Option::Some(_ic_set_27.clone());
+ return _ic_set_27;
+ } else {
+ return self._tr_cache_env_start_close_door.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_env_close_door(&mut self, is_caching: bool) -> HashSet<POSITION> {
+ //transition
+ if !is_caching || self._tr_cache_env_close_door.is_none() {
+ let mut _ic_set_28: HashSet<POSITION> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_gr_1 in self.gears.domain().clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if ((((((((((self.doors.functionCall(&_ic_gr_1).equal(&/*enum_call*/DOOR_STATE::door_moving) && self.gears.functionCall(&_ic_gr_1).unequal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.gears.range().notElementOf(&/*enum_call*/GEAR_STATE::gear_moving)) && self.doors.relationImage(&self._POSITION.difference(&bset![POSITION, _ic_gr_1])).equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::closed])) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && (self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted]) || self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended]))) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])))) && self.valve_close_door.equal(&/*enum_call*/VALVE_STATE::valve_open)) && (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])).implies(|| self.shock_absorber.equal(&/*enum_call*/PLANE_STATE::ground))) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) && self.door.equal(&/*enum_call*/DOOR_STATE::door_moving)) && self.gear.unequal(&/*enum_call*/GEAR_STATE::gear_moving)) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gear.equal(&/*enum_call*/GEAR_STATE::extended)) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended, /*enum_call*/GEAR_STATE::retracted].elementOf(&self.gear)))) {
+ _ic_set_28.insert(_ic_gr_1);
+ }
+
+ }
+ self._tr_cache_env_close_door = Option::Some(_ic_set_28.clone());
+ return _ic_set_28;
+ } else {
+ return self._tr_cache_env_close_door.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_env_close_door_skip(&mut self, is_caching: bool) -> HashSet<POSITION> {
+ //transition
+ if !is_caching || self._tr_cache_env_close_door_skip.is_none() {
+ let mut _ic_set_29: HashSet<POSITION> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_gr_1 in self.gears.domain().clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if (((((((self.doors.functionCall(&_ic_gr_1).equal(&/*enum_call*/DOOR_STATE::door_moving) && self.gears.functionCall(&_ic_gr_1).unequal(&/*enum_call*/GEAR_STATE::gear_moving)) && self.gears.range().notElementOf(&/*enum_call*/GEAR_STATE::gear_moving)) && self.doors.relationImage(&self._POSITION.difference(&bset![POSITION, _ic_gr_1])).unequal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::closed])) && ((self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && (self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted]) || self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended]))) || (self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])))) && self.valve_close_door.equal(&/*enum_call*/VALVE_STATE::valve_open)) && (self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])).implies(|| self.shock_absorber.equal(&/*enum_call*/PLANE_STATE::ground))) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open)) {
+ _ic_set_29.insert(_ic_gr_1);
+ }
+
+ }
+ self._tr_cache_env_close_door_skip = Option::Some(_ic_set_29.clone());
+ return _ic_set_29;
+ } else {
+ return self._tr_cache_env_close_door_skip.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_toggle_handle_up(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_toggle_handle_up.is_none() {
+ let mut __tmp__val__ = self.handle.equal(&/*enum_call*/HANDLE_STATE::down);
+ self._tr_cache_toggle_handle_up = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_toggle_handle_up.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_toggle_handle_down(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_toggle_handle_down.is_none() {
+ let mut __tmp__val__ = self.handle.equal(&/*enum_call*/HANDLE_STATE::up);
+ self._tr_cache_toggle_handle_down = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_toggle_handle_down.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_con_stimulate_general_valve(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_con_stimulate_general_valve.is_none() {
+ let mut __tmp__val__ = (self.general_EV.equal(&false) && self.handle_move.equal(&true));
+ self._tr_cache_con_stimulate_general_valve = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_con_stimulate_general_valve.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_con_stop_stimulate_general_valve(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_con_stop_stimulate_general_valve.is_none() {
+ let mut __tmp__val__ = ((((((self.general_EV.equal(&true) && self.open_EV.equal(&false)) && self.close_EV.equal(&false)) && self.retract_EV.equal(&false)) && self.extend_EV.equal(&false)) && self.close_EV.equal(&false)) && (((((self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted])) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::closed])) && self.open_EV.equal(&false)) || (((self.handle.equal(&/*enum_call*/HANDLE_STATE::down) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::closed])) && self.open_EV.equal(&false))) || (((self.handle.equal(&/*enum_call*/HANDLE_STATE::up) && self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended])) && self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::closed])) && self.open_EV.equal(&false))));
+ self._tr_cache_con_stop_stimulate_general_valve = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_con_stop_stimulate_general_valve.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_evn_open_general_valve(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_evn_open_general_valve.is_none() {
+ let mut __tmp__val__ = ((self.general_EV.equal(&true) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_closed)) && self.analogical_switch.equal(&/*enum_call*/SWITCH_STATE::switch_closed));
+ self._tr_cache_evn_open_general_valve = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_evn_open_general_valve.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_evn_close_general_valve(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_evn_close_general_valve.is_none() {
+ let mut __tmp__val__ = ((self.general_EV.equal(&false) || self.analogical_switch.equal(&/*enum_call*/SWITCH_STATE::switch_open)) && self.general_valve.equal(&/*enum_call*/VALVE_STATE::valve_open));
+ self._tr_cache_evn_close_general_valve = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_evn_close_general_valve.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_env_close_analogical_switch(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_env_close_analogical_switch.is_none() {
+ let mut __tmp__val__ = (self.analogical_switch.equal(&/*enum_call*/SWITCH_STATE::switch_open) && self.handle_move.equal(&true));
+ self._tr_cache_env_close_analogical_switch = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_env_close_analogical_switch.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_env_open_analogical_switch(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_env_open_analogical_switch.is_none() {
+ let mut __tmp__val__ = self.analogical_switch.equal(&/*enum_call*/SWITCH_STATE::switch_closed);
+ self._tr_cache_env_open_analogical_switch = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_env_open_analogical_switch.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _check_inv_1(&self) -> bool {
+ //invariant
+ return self._SWITCH_STATE.elementOf(&self.analogical_switch);
+ }
+
+ pub fn _check_inv_2(&self) -> bool {
+ //invariant
+ return BOOL.elementOf(&self.general_EV);
+ }
+
+ pub fn _check_inv_3(&self) -> bool {
+ //invariant
+ return self._VALVE_STATE.elementOf(&self.general_valve);
+ }
+
+ pub fn _check_inv_4(&self) -> bool {
+ //invariant
+ return BOOL.elementOf(&self.handle_move);
+ }
+
+ pub fn _check_inv_5(&self) -> bool {
+ //invariant
+ return BOOL.elementOf(&self.close_EV);
+ }
+
+ pub fn _check_inv_6(&self) -> bool {
+ //invariant
+ return BOOL.elementOf(&self.extend_EV);
+ }
+
+ pub fn _check_inv_7(&self) -> bool {
+ //invariant
+ return BOOL.elementOf(&self.open_EV);
+ }
+
+ pub fn _check_inv_8(&self) -> bool {
+ //invariant
+ return BOOL.elementOf(&self.retract_EV);
+ }
+
+ pub fn _check_inv_9(&self) -> bool {
+ //invariant
+ return self._PLANE_STATE.elementOf(&self.shock_absorber);
+ }
+
+ pub fn _check_inv_10(&self) -> bool {
+ //invariant
+ return self._VALVE_STATE.elementOf(&self.valve_close_door);
+ }
+
+ pub fn _check_inv_11(&self) -> bool {
+ //invariant
+ return self._VALVE_STATE.elementOf(&self.valve_extend_gear);
+ }
+
+ pub fn _check_inv_12(&self) -> bool {
+ //invariant
+ return self._VALVE_STATE.elementOf(&self.valve_open_door);
+ }
+
+ pub fn _check_inv_13(&self) -> bool {
+ //invariant
+ return self._VALVE_STATE.elementOf(&self.valve_retract_gear);
+ }
+
+ pub fn _check_inv_14(&self) -> bool {
+ //invariant
+ return self._HANDLE_STATE.elementOf(&self.handle);
+ }
+
+ pub fn _check_inv_15(&self) -> bool {
+ //invariant
+ return self._DOOR_STATE.elementOf(&self.door);
+ }
+
+ pub fn _check_inv_16(&self) -> bool {
+ //invariant
+ return self._GEAR_STATE.elementOf(&self.gear);
+ }
+
+ pub fn _check_inv_17(&self) -> bool {
+ //invariant
+ return (((self.open_EV.equal(&true) || self.close_EV.equal(&true)) || self.retract_EV.equal(&true)) || self.extend_EV.equal(&true)).implies(|| self.general_EV.equal(&true));
+ }
+
+ pub fn _check_inv_18(&self) -> bool {
+ //invariant
+ return (self.open_EV.equal(&true) && self.close_EV.equal(&true)).not();
+ }
+
+ pub fn _check_inv_19(&self) -> bool {
+ //invariant
+ return self._POSITION.check_domain_of(&self.gears).and(&self._GEAR_STATE.check_range_of(&self.gears)).and(&self.gears.isFunction()).and(&self._POSITION.check_total_of(&self.gears));
+ }
+
+ pub fn _check_inv_20(&self) -> bool {
+ //invariant
+ return self._POSITION.check_domain_of(&self.doors).and(&self._DOOR_STATE.check_range_of(&self.doors)).and(&self.doors.isFunction()).and(&self._POSITION.check_total_of(&self.doors));
+ }
+
+ pub fn _check_inv_21(&self) -> bool {
+ //invariant
+ return self.door.equal(&/*enum_call*/DOOR_STATE::closed).equivalent(&self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::closed]));
+ }
+
+ pub fn _check_inv_22(&self) -> bool {
+ //invariant
+ return self.door.equal(&/*enum_call*/DOOR_STATE::open).equivalent(&self.doors.range().equal(&bset![DOOR_STATE, /*enum_call*/DOOR_STATE::open]));
+ }
+
+ pub fn _check_inv_23(&self) -> bool {
+ //invariant
+ return self.gear.equal(&/*enum_call*/GEAR_STATE::extended).equivalent(&self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::extended]));
+ }
+
+ pub fn _check_inv_24(&self) -> bool {
+ //invariant
+ return self.gear.equal(&/*enum_call*/GEAR_STATE::retracted).equivalent(&self.gears.range().equal(&bset![GEAR_STATE, /*enum_call*/GEAR_STATE::retracted]));
+ }
+
+ pub fn _check_inv_25(&self) -> bool {
+ //invariant
+ return self.gear.equal(&/*enum_call*/GEAR_STATE::gear_moving).implies(|| self.door.equal(&/*enum_call*/DOOR_STATE::open));
+ }
+
+ fn invalidate_caches(&mut self, to_invalidate: Vec<&'static str>) {
+ //calling the given functions without caching will recalculate them and cache them afterwards
+ for trans in to_invalidate {
+ match trans {
+ "_tr_begin_flying" => {self._tr_begin_flying(false);},
+ "_tr_land_plane" => {self._tr_land_plane(false);},
+ "_tr_open_valve_door_open" => {self._tr_open_valve_door_open(false);},
+ "_tr_close_valve_door_open" => {self._tr_close_valve_door_open(false);},
+ "_tr_open_valve_door_close" => {self._tr_open_valve_door_close(false);},
+ "_tr_close_valve_door_close" => {self._tr_close_valve_door_close(false);},
+ "_tr_open_valve_retract_gear" => {self._tr_open_valve_retract_gear(false);},
+ "_tr_close_valve_retract_gear" => {self._tr_close_valve_retract_gear(false);},
+ "_tr_open_valve_extend_gear" => {self._tr_open_valve_extend_gear(false);},
+ "_tr_close_valve_extend_gear" => {self._tr_close_valve_extend_gear(false);},
+ "_tr_con_stimulate_open_door_valve" => {self._tr_con_stimulate_open_door_valve(false);},
+ "_tr_con_stop_stimulate_open_door_valve" => {self._tr_con_stop_stimulate_open_door_valve(false);},
+ "_tr_con_stimulate_close_door_valve" => {self._tr_con_stimulate_close_door_valve(false);},
+ "_tr_con_stop_stimulate_close_door_valve" => {self._tr_con_stop_stimulate_close_door_valve(false);},
+ "_tr_con_stimulate_retract_gear_valve" => {self._tr_con_stimulate_retract_gear_valve(false);},
+ "_tr_con_stop_stimulate_retract_gear_valve" => {self._tr_con_stop_stimulate_retract_gear_valve(false);},
+ "_tr_con_stimulate_extend_gear_valve" => {self._tr_con_stimulate_extend_gear_valve(false);},
+ "_tr_con_stop_stimulate_extend_gear_valve" => {self._tr_con_stop_stimulate_extend_gear_valve(false);},
+ "_tr_env_start_retracting_first" => {self._tr_env_start_retracting_first(false);},
+ "_tr_env_retract_gear_skip" => {self._tr_env_retract_gear_skip(false);},
+ "_tr_env_retract_gear_last" => {self._tr_env_retract_gear_last(false);},
+ "_tr_env_start_extending" => {self._tr_env_start_extending(false);},
+ "_tr_env_extend_gear_last" => {self._tr_env_extend_gear_last(false);},
+ "_tr_env_extend_gear_skip" => {self._tr_env_extend_gear_skip(false);},
+ "_tr_env_start_open_door" => {self._tr_env_start_open_door(false);},
+ "_tr_env_open_door_last" => {self._tr_env_open_door_last(false);},
+ "_tr_env_open_door_skip" => {self._tr_env_open_door_skip(false);},
+ "_tr_env_start_close_door" => {self._tr_env_start_close_door(false);},
+ "_tr_env_close_door" => {self._tr_env_close_door(false);},
+ "_tr_env_close_door_skip" => {self._tr_env_close_door_skip(false);},
+ "_tr_toggle_handle_up" => {self._tr_toggle_handle_up(false);},
+ "_tr_toggle_handle_down" => {self._tr_toggle_handle_down(false);},
+ "_tr_con_stimulate_general_valve" => {self._tr_con_stimulate_general_valve(false);},
+ "_tr_con_stop_stimulate_general_valve" => {self._tr_con_stop_stimulate_general_valve(false);},
+ "_tr_evn_open_general_valve" => {self._tr_evn_open_general_valve(false);},
+ "_tr_evn_close_general_valve" => {self._tr_evn_close_general_valve(false);},
+ "_tr_env_close_analogical_switch" => {self._tr_env_close_analogical_switch(false);},
+ "_tr_env_open_analogical_switch" => {self._tr_env_open_analogical_switch(false);},
+ _ => {},
+ }
+ }
+ }
+
+ //model_check_next_states
+ fn generateNextStates(state: &mut LandingGear_R6,
+ isCaching: bool,
+ transitions: Arc<AtomicU64>) -> HashSet<(LandingGear_R6, &'static str)> {
+ let mut result = HashSet::<(LandingGear_R6, &'static str)>::new();
+ let mut evaluated_transitions: u64 = 0;
+ //model_check_transition
+ if state._tr_begin_flying(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.begin_flying();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("begin_flying")); }
+ result.insert((copiedState, "begin_flying"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_land_plane(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.land_plane();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("land_plane")); }
+ result.insert((copiedState, "land_plane"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_open_valve_door_open(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.open_valve_door_open();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("open_valve_door_open")); }
+ result.insert((copiedState, "open_valve_door_open"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_close_valve_door_open(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.close_valve_door_open();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("close_valve_door_open")); }
+ result.insert((copiedState, "close_valve_door_open"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_open_valve_door_close(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.open_valve_door_close();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("open_valve_door_close")); }
+ result.insert((copiedState, "open_valve_door_close"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_close_valve_door_close(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.close_valve_door_close();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("close_valve_door_close")); }
+ result.insert((copiedState, "close_valve_door_close"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_open_valve_retract_gear(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.open_valve_retract_gear();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("open_valve_retract_gear")); }
+ result.insert((copiedState, "open_valve_retract_gear"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_close_valve_retract_gear(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.close_valve_retract_gear();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("close_valve_retract_gear")); }
+ result.insert((copiedState, "close_valve_retract_gear"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_open_valve_extend_gear(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.open_valve_extend_gear();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("open_valve_extend_gear")); }
+ result.insert((copiedState, "open_valve_extend_gear"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_close_valve_extend_gear(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.close_valve_extend_gear();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("close_valve_extend_gear")); }
+ result.insert((copiedState, "close_valve_extend_gear"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_con_stimulate_open_door_valve(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.con_stimulate_open_door_valve();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("con_stimulate_open_door_valve")); }
+ result.insert((copiedState, "con_stimulate_open_door_valve"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_con_stop_stimulate_open_door_valve(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.con_stop_stimulate_open_door_valve();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("con_stop_stimulate_open_door_valve")); }
+ result.insert((copiedState, "con_stop_stimulate_open_door_valve"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_con_stimulate_close_door_valve(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.con_stimulate_close_door_valve();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("con_stimulate_close_door_valve")); }
+ result.insert((copiedState, "con_stimulate_close_door_valve"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_con_stop_stimulate_close_door_valve(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.con_stop_stimulate_close_door_valve();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("con_stop_stimulate_close_door_valve")); }
+ result.insert((copiedState, "con_stop_stimulate_close_door_valve"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_con_stimulate_retract_gear_valve(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.con_stimulate_retract_gear_valve();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("con_stimulate_retract_gear_valve")); }
+ result.insert((copiedState, "con_stimulate_retract_gear_valve"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_con_stop_stimulate_retract_gear_valve(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.con_stop_stimulate_retract_gear_valve();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("con_stop_stimulate_retract_gear_valve")); }
+ result.insert((copiedState, "con_stop_stimulate_retract_gear_valve"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_con_stimulate_extend_gear_valve(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.con_stimulate_extend_gear_valve();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("con_stimulate_extend_gear_valve")); }
+ result.insert((copiedState, "con_stimulate_extend_gear_valve"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_con_stop_stimulate_extend_gear_valve(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.con_stop_stimulate_extend_gear_valve();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("con_stop_stimulate_extend_gear_valve")); }
+ result.insert((copiedState, "con_stop_stimulate_extend_gear_valve"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_19 = state._tr_env_start_retracting_first(isCaching);
+ for param in _trid_19.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.env_start_retracting_first(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("env_start_retracting_first")); }
+ result.insert((copiedState, "env_start_retracting_first"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_20 = state._tr_env_retract_gear_skip(isCaching);
+ for param in _trid_20.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.env_retract_gear_skip(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("env_retract_gear_skip")); }
+ result.insert((copiedState, "env_retract_gear_skip"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_21 = state._tr_env_retract_gear_last(isCaching);
+ for param in _trid_21.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.env_retract_gear_last(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("env_retract_gear_last")); }
+ result.insert((copiedState, "env_retract_gear_last"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_22 = state._tr_env_start_extending(isCaching);
+ for param in _trid_22.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.env_start_extending(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("env_start_extending")); }
+ result.insert((copiedState, "env_start_extending"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_23 = state._tr_env_extend_gear_last(isCaching);
+ for param in _trid_23.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.env_extend_gear_last(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("env_extend_gear_last")); }
+ result.insert((copiedState, "env_extend_gear_last"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_24 = state._tr_env_extend_gear_skip(isCaching);
+ for param in _trid_24.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.env_extend_gear_skip(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("env_extend_gear_skip")); }
+ result.insert((copiedState, "env_extend_gear_skip"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_25 = state._tr_env_start_open_door(isCaching);
+ for param in _trid_25.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.env_start_open_door(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("env_start_open_door")); }
+ result.insert((copiedState, "env_start_open_door"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_26 = state._tr_env_open_door_last(isCaching);
+ for param in _trid_26.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.env_open_door_last(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("env_open_door_last")); }
+ result.insert((copiedState, "env_open_door_last"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_27 = state._tr_env_open_door_skip(isCaching);
+ for param in _trid_27.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.env_open_door_skip(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("env_open_door_skip")); }
+ result.insert((copiedState, "env_open_door_skip"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_28 = state._tr_env_start_close_door(isCaching);
+ for param in _trid_28.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.env_start_close_door(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("env_start_close_door")); }
+ result.insert((copiedState, "env_start_close_door"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_29 = state._tr_env_close_door(isCaching);
+ for param in _trid_29.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.env_close_door(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("env_close_door")); }
+ result.insert((copiedState, "env_close_door"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_30 = state._tr_env_close_door_skip(isCaching);
+ for param in _trid_30.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.env_close_door_skip(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("env_close_door_skip")); }
+ result.insert((copiedState, "env_close_door_skip"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_toggle_handle_up(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.toggle_handle_up();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("toggle_handle_up")); }
+ result.insert((copiedState, "toggle_handle_up"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_toggle_handle_down(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.toggle_handle_down();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("toggle_handle_down")); }
+ result.insert((copiedState, "toggle_handle_down"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_con_stimulate_general_valve(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.con_stimulate_general_valve();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("con_stimulate_general_valve")); }
+ result.insert((copiedState, "con_stimulate_general_valve"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_con_stop_stimulate_general_valve(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.con_stop_stimulate_general_valve();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("con_stop_stimulate_general_valve")); }
+ result.insert((copiedState, "con_stop_stimulate_general_valve"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_evn_open_general_valve(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.evn_open_general_valve();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("evn_open_general_valve")); }
+ result.insert((copiedState, "evn_open_general_valve"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_evn_close_general_valve(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.evn_close_general_valve();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("evn_close_general_valve")); }
+ result.insert((copiedState, "evn_close_general_valve"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_env_close_analogical_switch(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.env_close_analogical_switch();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("env_close_analogical_switch")); }
+ result.insert((copiedState, "env_close_analogical_switch"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_env_open_analogical_switch(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.env_open_analogical_switch();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("env_open_analogical_switch")); }
+ result.insert((copiedState, "env_open_analogical_switch"));
+ evaluated_transitions += 1;
+ }
+
+
+ transitions.fetch_add(evaluated_transitions, Ordering::AcqRel);
+ return result;
+ }
+
+ //model_check_invariants
+ pub fn checkInvariants(state: &LandingGear_R6, last_op: &'static str, isCaching: bool) -> bool {
+ if isCaching {
+ let dependent_invariants_of_state = Self::get_invariant_dependencies(last_op);
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_1") {
+ if !state._check_inv_1() {
+ println!("_check_inv_1 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_2") {
+ if !state._check_inv_2() {
+ println!("_check_inv_2 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_3") {
+ if !state._check_inv_3() {
+ println!("_check_inv_3 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_4") {
+ if !state._check_inv_4() {
+ println!("_check_inv_4 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_5") {
+ if !state._check_inv_5() {
+ println!("_check_inv_5 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_6") {
+ if !state._check_inv_6() {
+ println!("_check_inv_6 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_7") {
+ if !state._check_inv_7() {
+ println!("_check_inv_7 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_8") {
+ if !state._check_inv_8() {
+ println!("_check_inv_8 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_9") {
+ if !state._check_inv_9() {
+ println!("_check_inv_9 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_10") {
+ if !state._check_inv_10() {
+ println!("_check_inv_10 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_11") {
+ if !state._check_inv_11() {
+ println!("_check_inv_11 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_12") {
+ if !state._check_inv_12() {
+ println!("_check_inv_12 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_13") {
+ if !state._check_inv_13() {
+ println!("_check_inv_13 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_14") {
+ if !state._check_inv_14() {
+ println!("_check_inv_14 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_15") {
+ if !state._check_inv_15() {
+ println!("_check_inv_15 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_16") {
+ if !state._check_inv_16() {
+ println!("_check_inv_16 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_17") {
+ if !state._check_inv_17() {
+ println!("_check_inv_17 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_18") {
+ if !state._check_inv_18() {
+ println!("_check_inv_18 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_19") {
+ if !state._check_inv_19() {
+ println!("_check_inv_19 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_20") {
+ if !state._check_inv_20() {
+ println!("_check_inv_20 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_21") {
+ if !state._check_inv_21() {
+ println!("_check_inv_21 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_22") {
+ if !state._check_inv_22() {
+ println!("_check_inv_22 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_23") {
+ if !state._check_inv_23() {
+ println!("_check_inv_23 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_24") {
+ if !state._check_inv_24() {
+ println!("_check_inv_24 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_25") {
+ if !state._check_inv_25() {
+ println!("_check_inv_25 failed!");
+ return false;
+ }
+ }
+ return true;
+ }
+ return !(!state._check_inv_1() || !state._check_inv_2() || !state._check_inv_3() || !state._check_inv_4() || !state._check_inv_5() || !state._check_inv_6() || !state._check_inv_7() || !state._check_inv_8() || !state._check_inv_9() || !state._check_inv_10() || !state._check_inv_11() || !state._check_inv_12() || !state._check_inv_13() || !state._check_inv_14() || !state._check_inv_15() || !state._check_inv_16() || !state._check_inv_17() || !state._check_inv_18() || !state._check_inv_19() || !state._check_inv_20() || !state._check_inv_21() || !state._check_inv_22() || !state._check_inv_23() || !state._check_inv_24() || !state._check_inv_25());
+ }
+
+ //model_check_print
+ fn print_result(states: usize, transitions: u64, error_detected: bool) {
+ if !error_detected { println!("MODEL CHECKING SUCCESSFUL"); }
+ println!("Number of States: {}", states);
+ println!("Number of Transitions: {}", transitions);
+ }
+
+ //model_check_main
+ fn next(collection_m: Arc<Mutex<LinkedList<(LandingGear_R6, &'static str)>>>, mc_type: MC_TYPE) -> (LandingGear_R6, &'static str) {
+ let mut collection = collection_m.lock().unwrap();
+ return match mc_type {
+ MC_TYPE::BFS => collection.pop_front().unwrap(),
+ MC_TYPE::DFS => collection.pop_back().unwrap(),
+ MC_TYPE::MIXED => if collection.len() % 2 == 0 { collection.pop_front().unwrap() } else { collection.pop_back().unwrap() }
+ };
+ }
+
+ fn get_guard_dependencies(op: &'static str) -> Vec<&str> {
+ return match op {
+ //model_check_init_static
+ "close_valve_door_close" => vec!["_tr_open_valve_door_close", "_tr_env_close_door_skip", "_tr_env_start_close_door", "_tr_env_close_door", "_tr_close_valve_door_close"],
+ //model_check_init_static
+ "close_valve_retract_gear" => vec!["_tr_close_valve_retract_gear", "_tr_open_valve_retract_gear", "_tr_env_start_retracting_first"],
+ //model_check_init_static
+ "con_stimulate_open_door_valve" => vec!["_tr_open_valve_door_open", "_tr_con_stimulate_extend_gear_valve", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_con_stop_stimulate_general_valve", "_tr_con_stimulate_open_door_valve", "_tr_close_valve_door_open"],
+ //model_check_init_static
+ "env_close_door" => vec!["_tr_env_retract_gear_last", "_tr_con_stimulate_extend_gear_valve", "_tr_env_close_door_skip", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_env_retract_gear_skip", "_tr_env_start_open_door", "_tr_env_close_door", "_tr_env_start_retracting_first", "_tr_env_extend_gear_skip", "_tr_env_open_door_last", "_tr_env_start_close_door", "_tr_con_stop_stimulate_general_valve", "_tr_con_stop_stimulate_close_door_valve", "_tr_con_stimulate_open_door_valve", "_tr_env_start_extending", "_tr_env_extend_gear_last", "_tr_env_open_door_skip"],
+ //model_check_init_static
+ "env_start_close_door" => vec!["_tr_env_retract_gear_last", "_tr_con_stimulate_extend_gear_valve", "_tr_env_close_door_skip", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_env_retract_gear_skip", "_tr_env_start_open_door", "_tr_env_close_door", "_tr_env_start_retracting_first", "_tr_env_extend_gear_skip", "_tr_env_open_door_last", "_tr_env_start_close_door", "_tr_con_stop_stimulate_general_valve", "_tr_con_stop_stimulate_close_door_valve", "_tr_con_stimulate_open_door_valve", "_tr_env_start_extending", "_tr_env_extend_gear_last", "_tr_env_open_door_skip"],
+ //model_check_init_static
+ "toggle_handle_up" => vec!["_tr_env_retract_gear_last", "_tr_con_stimulate_extend_gear_valve", "_tr_env_close_door_skip", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_close_door_valve", "_tr_env_close_analogical_switch", "_tr_con_stop_stimulate_retract_gear_valve", "_tr_con_stop_stimulate_general_valve", "_tr_con_stimulate_open_door_valve", "_tr_env_start_extending", "_tr_env_extend_gear_last", "_tr_env_open_door_skip", "_tr_con_stimulate_general_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_env_retract_gear_skip", "_tr_env_start_open_door", "_tr_env_close_door", "_tr_con_stop_stimulate_extend_gear_valve", "_tr_env_start_retracting_first", "_tr_env_extend_gear_skip", "_tr_toggle_handle_down", "_tr_env_open_door_last", "_tr_toggle_handle_up", "_tr_env_start_close_door", "_tr_con_stop_stimulate_close_door_valve"],
+ //model_check_init_static
+ "toggle_handle_down" => vec!["_tr_env_retract_gear_last", "_tr_con_stimulate_extend_gear_valve", "_tr_env_close_door_skip", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_close_door_valve", "_tr_env_close_analogical_switch", "_tr_con_stop_stimulate_retract_gear_valve", "_tr_con_stop_stimulate_general_valve", "_tr_con_stimulate_open_door_valve", "_tr_env_start_extending", "_tr_env_extend_gear_last", "_tr_env_open_door_skip", "_tr_con_stimulate_general_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_env_retract_gear_skip", "_tr_env_start_open_door", "_tr_env_close_door", "_tr_con_stop_stimulate_extend_gear_valve", "_tr_env_start_retracting_first", "_tr_env_extend_gear_skip", "_tr_toggle_handle_down", "_tr_env_open_door_last", "_tr_toggle_handle_up", "_tr_env_start_close_door", "_tr_con_stop_stimulate_close_door_valve"],
+ //model_check_init_static
+ "open_valve_door_open" => vec!["_tr_open_valve_door_open", "_tr_env_open_door_last", "_tr_env_start_open_door", "_tr_env_open_door_skip", "_tr_close_valve_door_open"],
+ //model_check_init_static
+ "env_retract_gear_last" => vec!["_tr_env_retract_gear_last", "_tr_con_stimulate_extend_gear_valve", "_tr_env_close_door_skip", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_env_retract_gear_skip", "_tr_env_start_open_door", "_tr_env_close_door", "_tr_con_stop_stimulate_extend_gear_valve", "_tr_env_start_retracting_first", "_tr_con_stop_stimulate_retract_gear_valve", "_tr_env_extend_gear_skip", "_tr_env_open_door_last", "_tr_env_start_close_door", "_tr_con_stop_stimulate_general_valve", "_tr_con_stop_stimulate_close_door_valve", "_tr_con_stimulate_open_door_valve", "_tr_env_start_extending", "_tr_env_extend_gear_last", "_tr_env_open_door_skip"],
+ //model_check_init_static
+ "env_open_door_last" => vec!["_tr_env_retract_gear_last", "_tr_con_stimulate_extend_gear_valve", "_tr_env_close_door_skip", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_env_retract_gear_skip", "_tr_env_start_open_door", "_tr_env_close_door", "_tr_env_start_retracting_first", "_tr_env_extend_gear_skip", "_tr_env_open_door_last", "_tr_env_start_close_door", "_tr_con_stop_stimulate_general_valve", "_tr_con_stop_stimulate_close_door_valve", "_tr_con_stimulate_open_door_valve", "_tr_env_start_extending", "_tr_env_extend_gear_last", "_tr_env_open_door_skip"],
+ //model_check_init_static
+ "con_stop_stimulate_retract_gear_valve" => vec!["_tr_close_valve_retract_gear", "_tr_con_stimulate_extend_gear_valve", "_tr_open_valve_retract_gear", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_con_stop_stimulate_general_valve", "_tr_con_stop_stimulate_retract_gear_valve"],
+ //model_check_init_static
+ "env_close_door_skip" => vec!["_tr_env_retract_gear_last", "_tr_con_stimulate_extend_gear_valve", "_tr_env_close_door_skip", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_env_retract_gear_skip", "_tr_env_start_open_door", "_tr_env_close_door", "_tr_env_start_retracting_first", "_tr_env_extend_gear_skip", "_tr_env_open_door_last", "_tr_env_start_close_door", "_tr_con_stop_stimulate_general_valve", "_tr_con_stop_stimulate_close_door_valve", "_tr_con_stimulate_open_door_valve", "_tr_env_start_extending", "_tr_env_extend_gear_last", "_tr_env_open_door_skip"],
+ //model_check_init_static
+ "con_stop_stimulate_close_door_valve" => vec!["_tr_open_valve_door_close", "_tr_con_stimulate_close_door_valve", "_tr_con_stop_stimulate_general_valve", "_tr_con_stop_stimulate_close_door_valve", "_tr_con_stimulate_open_door_valve", "_tr_close_valve_door_close"],
+ //model_check_init_static
+ "env_open_analogical_switch" => vec!["_tr_env_open_analogical_switch", "_tr_evn_open_general_valve", "_tr_env_close_analogical_switch", "_tr_evn_close_general_valve"],
+ //model_check_init_static
+ "con_stop_stimulate_general_valve" => vec!["_tr_con_stimulate_extend_gear_valve", "_tr_con_stimulate_general_valve", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_evn_open_general_valve", "_tr_env_close_analogical_switch", "_tr_con_stop_stimulate_extend_gear_valve", "_tr_evn_close_general_valve", "_tr_con_stop_stimulate_retract_gear_valve", "_tr_con_stop_stimulate_general_valve", "_tr_con_stop_stimulate_close_door_valve", "_tr_con_stimulate_open_door_valve"],
+ //model_check_init_static
+ "env_extend_gear_last" => vec!["_tr_env_retract_gear_last", "_tr_con_stimulate_extend_gear_valve", "_tr_env_close_door_skip", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_env_retract_gear_skip", "_tr_env_start_open_door", "_tr_env_close_door", "_tr_con_stop_stimulate_extend_gear_valve", "_tr_env_start_retracting_first", "_tr_con_stop_stimulate_retract_gear_valve", "_tr_env_extend_gear_skip", "_tr_env_open_door_last", "_tr_env_start_close_door", "_tr_con_stop_stimulate_general_valve", "_tr_con_stop_stimulate_close_door_valve", "_tr_con_stimulate_open_door_valve", "_tr_env_start_extending", "_tr_env_extend_gear_last", "_tr_env_open_door_skip"],
+ //model_check_init_static
+ "evn_open_general_valve" => vec!["_tr_env_retract_gear_last", "_tr_env_close_door_skip", "_tr_evn_open_general_valve", "_tr_env_retract_gear_skip", "_tr_env_start_open_door", "_tr_env_close_door", "_tr_evn_close_general_valve", "_tr_env_start_retracting_first", "_tr_env_extend_gear_skip", "_tr_env_open_door_last", "_tr_env_start_close_door", "_tr_env_start_extending", "_tr_env_extend_gear_last", "_tr_env_open_door_skip"],
+ //model_check_init_static
+ "land_plane" => vec!["_tr_land_plane", "_tr_begin_flying", "_tr_env_close_door_skip", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_con_stop_stimulate_close_door_valve", "_tr_con_stimulate_open_door_valve", "_tr_env_close_door"],
+ //model_check_init_static
+ "con_stimulate_retract_gear_valve" => vec!["_tr_close_valve_retract_gear", "_tr_con_stimulate_extend_gear_valve", "_tr_open_valve_retract_gear", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_con_stop_stimulate_general_valve", "_tr_con_stop_stimulate_retract_gear_valve"],
+ //model_check_init_static
+ "con_stimulate_general_valve" => vec!["_tr_con_stimulate_extend_gear_valve", "_tr_con_stimulate_general_valve", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_evn_open_general_valve", "_tr_con_stop_stimulate_general_valve", "_tr_con_stop_stimulate_close_door_valve", "_tr_con_stimulate_open_door_valve", "_tr_con_stop_stimulate_extend_gear_valve", "_tr_evn_close_general_valve", "_tr_con_stop_stimulate_retract_gear_valve"],
+ //model_check_init_static
+ "env_start_retracting_first" => vec!["_tr_env_retract_gear_last", "_tr_con_stimulate_extend_gear_valve", "_tr_env_close_door_skip", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_env_retract_gear_skip", "_tr_env_start_open_door", "_tr_env_close_door", "_tr_con_stop_stimulate_extend_gear_valve", "_tr_env_start_retracting_first", "_tr_con_stop_stimulate_retract_gear_valve", "_tr_env_extend_gear_skip", "_tr_env_open_door_last", "_tr_env_start_close_door", "_tr_con_stop_stimulate_general_valve", "_tr_con_stop_stimulate_close_door_valve", "_tr_con_stimulate_open_door_valve", "_tr_env_start_extending", "_tr_env_extend_gear_last", "_tr_env_open_door_skip"],
+ //model_check_init_static
+ "env_retract_gear_skip" => vec!["_tr_env_retract_gear_last", "_tr_con_stimulate_extend_gear_valve", "_tr_env_close_door_skip", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_env_retract_gear_skip", "_tr_env_start_open_door", "_tr_env_close_door", "_tr_con_stop_stimulate_extend_gear_valve", "_tr_env_start_retracting_first", "_tr_con_stop_stimulate_retract_gear_valve", "_tr_env_extend_gear_skip", "_tr_env_open_door_last", "_tr_env_start_close_door", "_tr_con_stop_stimulate_general_valve", "_tr_con_stop_stimulate_close_door_valve", "_tr_con_stimulate_open_door_valve", "_tr_env_start_extending", "_tr_env_extend_gear_last", "_tr_env_open_door_skip"],
+ //model_check_init_static
+ "open_valve_extend_gear" => vec!["_tr_close_valve_extend_gear", "_tr_open_valve_extend_gear", "_tr_env_start_extending"],
+ //model_check_init_static
+ "begin_flying" => vec!["_tr_land_plane", "_tr_begin_flying", "_tr_env_close_door_skip", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_con_stop_stimulate_close_door_valve", "_tr_con_stimulate_open_door_valve", "_tr_env_close_door"],
+ //model_check_init_static
+ "open_valve_retract_gear" => vec!["_tr_close_valve_retract_gear", "_tr_open_valve_retract_gear", "_tr_env_start_retracting_first"],
+ //model_check_init_static
+ "env_close_analogical_switch" => vec!["_tr_env_open_analogical_switch", "_tr_evn_open_general_valve", "_tr_env_close_analogical_switch", "_tr_evn_close_general_valve"],
+ //model_check_init_static
+ "env_start_extending" => vec!["_tr_env_retract_gear_last", "_tr_con_stimulate_extend_gear_valve", "_tr_env_close_door_skip", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_env_retract_gear_skip", "_tr_env_start_open_door", "_tr_env_close_door", "_tr_con_stop_stimulate_extend_gear_valve", "_tr_env_start_retracting_first", "_tr_con_stop_stimulate_retract_gear_valve", "_tr_env_extend_gear_skip", "_tr_env_open_door_last", "_tr_env_start_close_door", "_tr_con_stop_stimulate_general_valve", "_tr_con_stop_stimulate_close_door_valve", "_tr_con_stimulate_open_door_valve", "_tr_env_start_extending", "_tr_env_extend_gear_last", "_tr_env_open_door_skip"],
+ //model_check_init_static
+ "open_valve_door_close" => vec!["_tr_open_valve_door_close", "_tr_env_close_door_skip", "_tr_env_start_close_door", "_tr_env_close_door", "_tr_close_valve_door_close"],
+ //model_check_init_static
+ "con_stop_stimulate_open_door_valve" => vec!["_tr_open_valve_door_open", "_tr_con_stimulate_extend_gear_valve", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_con_stop_stimulate_general_valve", "_tr_con_stimulate_open_door_valve", "_tr_close_valve_door_open"],
+ //model_check_init_static
+ "con_stop_stimulate_extend_gear_valve" => vec!["_tr_con_stimulate_extend_gear_valve", "_tr_close_valve_extend_gear", "_tr_con_stop_stimulate_open_door_valve", "_tr_open_valve_extend_gear", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_con_stop_stimulate_general_valve", "_tr_con_stop_stimulate_extend_gear_valve"],
+ //model_check_init_static
+ "evn_close_general_valve" => vec!["_tr_env_retract_gear_last", "_tr_env_close_door_skip", "_tr_evn_open_general_valve", "_tr_env_retract_gear_skip", "_tr_env_start_open_door", "_tr_env_close_door", "_tr_evn_close_general_valve", "_tr_env_start_retracting_first", "_tr_env_extend_gear_skip", "_tr_env_open_door_last", "_tr_env_start_close_door", "_tr_env_start_extending", "_tr_env_extend_gear_last", "_tr_env_open_door_skip"],
+ //model_check_init_static
+ "close_valve_extend_gear" => vec!["_tr_close_valve_extend_gear", "_tr_open_valve_extend_gear", "_tr_env_start_extending"],
+ //model_check_init_static
+ "con_stimulate_extend_gear_valve" => vec!["_tr_con_stimulate_extend_gear_valve", "_tr_close_valve_extend_gear", "_tr_con_stop_stimulate_open_door_valve", "_tr_open_valve_extend_gear", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_con_stop_stimulate_general_valve", "_tr_con_stop_stimulate_extend_gear_valve"],
+ //model_check_init_static
+ "close_valve_door_open" => vec!["_tr_open_valve_door_open", "_tr_env_open_door_last", "_tr_env_start_open_door", "_tr_env_open_door_skip", "_tr_close_valve_door_open"],
+ //model_check_init_static
+ "con_stimulate_close_door_valve" => vec!["_tr_open_valve_door_close", "_tr_con_stimulate_close_door_valve", "_tr_con_stop_stimulate_general_valve", "_tr_con_stop_stimulate_close_door_valve", "_tr_con_stimulate_open_door_valve", "_tr_close_valve_door_close"],
+ //model_check_init_static
+ "env_extend_gear_skip" => vec!["_tr_env_retract_gear_last", "_tr_con_stimulate_extend_gear_valve", "_tr_env_close_door_skip", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_env_retract_gear_skip", "_tr_env_start_open_door", "_tr_env_close_door", "_tr_con_stop_stimulate_extend_gear_valve", "_tr_env_start_retracting_first", "_tr_con_stop_stimulate_retract_gear_valve", "_tr_env_extend_gear_skip", "_tr_env_open_door_last", "_tr_env_start_close_door", "_tr_con_stop_stimulate_general_valve", "_tr_con_stop_stimulate_close_door_valve", "_tr_con_stimulate_open_door_valve", "_tr_env_start_extending", "_tr_env_extend_gear_last", "_tr_env_open_door_skip"],
+ //model_check_init_static
+ "env_open_door_skip" => vec!["_tr_env_retract_gear_last", "_tr_con_stimulate_extend_gear_valve", "_tr_env_close_door_skip", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_env_retract_gear_skip", "_tr_env_start_open_door", "_tr_env_close_door", "_tr_env_start_retracting_first", "_tr_env_extend_gear_skip", "_tr_env_open_door_last", "_tr_env_start_close_door", "_tr_con_stop_stimulate_general_valve", "_tr_con_stop_stimulate_close_door_valve", "_tr_con_stimulate_open_door_valve", "_tr_env_start_extending", "_tr_env_extend_gear_last", "_tr_env_open_door_skip"],
+ //model_check_init_static
+ "env_start_open_door" => vec!["_tr_env_retract_gear_last", "_tr_con_stimulate_extend_gear_valve", "_tr_env_close_door_skip", "_tr_con_stop_stimulate_open_door_valve", "_tr_con_stimulate_retract_gear_valve", "_tr_con_stimulate_close_door_valve", "_tr_env_retract_gear_skip", "_tr_env_start_open_door", "_tr_env_close_door", "_tr_env_start_retracting_first", "_tr_env_extend_gear_skip", "_tr_env_open_door_last", "_tr_env_start_close_door", "_tr_con_stop_stimulate_general_valve", "_tr_con_stop_stimulate_close_door_valve", "_tr_con_stimulate_open_door_valve", "_tr_env_start_extending", "_tr_env_extend_gear_last", "_tr_env_open_door_skip"],
+ _ => vec![],
+ }
+ }
+
+ fn get_invariant_dependencies(op: &'static str) -> Vec<&str> {
+ return match op {
+ //model_check_init_static
+ "close_valve_door_close" => vec!["_check_inv_10"],
+ //model_check_init_static
+ "close_valve_retract_gear" => vec!["_check_inv_13"],
+ //model_check_init_static
+ "con_stimulate_open_door_valve" => vec!["_check_inv_18", "_check_inv_17", "_check_inv_7"],
+ //model_check_init_static
+ "env_close_door" => vec!["_check_inv_15", "_check_inv_21", "_check_inv_20", "_check_inv_25", "_check_inv_22"],
+ //model_check_init_static
+ "env_start_close_door" => vec!["_check_inv_15", "_check_inv_21", "_check_inv_20", "_check_inv_25", "_check_inv_22"],
+ //model_check_init_static
+ "toggle_handle_up" => vec!["_check_inv_4", "_check_inv_14"],
+ //model_check_init_static
+ "toggle_handle_down" => vec!["_check_inv_4", "_check_inv_14"],
+ //model_check_init_static
+ "open_valve_door_open" => vec!["_check_inv_12"],
+ //model_check_init_static
+ "env_retract_gear_last" => vec!["_check_inv_16", "_check_inv_19", "_check_inv_25", "_check_inv_24", "_check_inv_23"],
+ //model_check_init_static
+ "env_open_door_last" => vec!["_check_inv_15", "_check_inv_21", "_check_inv_20", "_check_inv_25", "_check_inv_22"],
+ //model_check_init_static
+ "con_stop_stimulate_retract_gear_valve" => vec!["_check_inv_17", "_check_inv_8"],
+ //model_check_init_static
+ "env_close_door_skip" => vec!["_check_inv_21", "_check_inv_20", "_check_inv_22"],
+ //model_check_init_static
+ "con_stop_stimulate_close_door_valve" => vec!["_check_inv_18", "_check_inv_17", "_check_inv_5"],
+ //model_check_init_static
+ "env_open_analogical_switch" => vec!["_check_inv_1"],
+ //model_check_init_static
+ "con_stop_stimulate_general_valve" => vec!["_check_inv_17", "_check_inv_2", "_check_inv_4"],
+ //model_check_init_static
+ "env_extend_gear_last" => vec!["_check_inv_16", "_check_inv_19", "_check_inv_25", "_check_inv_24", "_check_inv_23"],
+ //model_check_init_static
+ "evn_open_general_valve" => vec!["_check_inv_3"],
+ //model_check_init_static
+ "land_plane" => vec!["_check_inv_9"],
+ //model_check_init_static
+ "con_stimulate_retract_gear_valve" => vec!["_check_inv_17", "_check_inv_8"],
+ //model_check_init_static
+ "con_stimulate_general_valve" => vec!["_check_inv_17", "_check_inv_2"],
+ //model_check_init_static
+ "env_start_retracting_first" => vec!["_check_inv_16", "_check_inv_19", "_check_inv_25", "_check_inv_24", "_check_inv_23"],
+ //model_check_init_static
+ "env_retract_gear_skip" => vec!["_check_inv_19", "_check_inv_24", "_check_inv_23"],
+ //model_check_init_static
+ "open_valve_extend_gear" => vec!["_check_inv_11"],
+ //model_check_init_static
+ "begin_flying" => vec!["_check_inv_9"],
+ //model_check_init_static
+ "open_valve_retract_gear" => vec!["_check_inv_13"],
+ //model_check_init_static
+ "env_close_analogical_switch" => vec!["_check_inv_1"],
+ //model_check_init_static
+ "env_start_extending" => vec!["_check_inv_16", "_check_inv_19", "_check_inv_25", "_check_inv_24", "_check_inv_23"],
+ //model_check_init_static
+ "open_valve_door_close" => vec!["_check_inv_10"],
+ //model_check_init_static
+ "con_stop_stimulate_open_door_valve" => vec!["_check_inv_18", "_check_inv_17", "_check_inv_7"],
+ //model_check_init_static
+ "con_stop_stimulate_extend_gear_valve" => vec!["_check_inv_17", "_check_inv_6"],
+ //model_check_init_static
+ "evn_close_general_valve" => vec!["_check_inv_3"],
+ //model_check_init_static
+ "close_valve_extend_gear" => vec!["_check_inv_11"],
+ //model_check_init_static
+ "con_stimulate_extend_gear_valve" => vec!["_check_inv_17", "_check_inv_6"],
+ //model_check_init_static
+ "close_valve_door_open" => vec!["_check_inv_12"],
+ //model_check_init_static
+ "con_stimulate_close_door_valve" => vec!["_check_inv_18", "_check_inv_17", "_check_inv_5"],
+ //model_check_init_static
+ "env_extend_gear_skip" => vec!["_check_inv_19", "_check_inv_24", "_check_inv_23"],
+ //model_check_init_static
+ "env_open_door_skip" => vec!["_check_inv_21", "_check_inv_20", "_check_inv_22"],
+ //model_check_init_static
+ "env_start_open_door" => vec!["_check_inv_15", "_check_inv_21", "_check_inv_20", "_check_inv_25", "_check_inv_22"],
+ _ => vec![],
+ }
+ }
+
+ fn model_check_single_threaded(mc_type: MC_TYPE, is_caching: bool, no_dead: bool, no_inv: bool) {
+ let mut machine = LandingGear_R6::new();
+
+ let mut all_states = HashSet::<LandingGear_R6>::new();
+ all_states.insert(machine.clone());
+
+ let states_to_process_mutex = Arc::new(Mutex::new(LinkedList::<(LandingGear_R6, &'static str)>::new()));
+ states_to_process_mutex.lock().unwrap().push_back((machine.clone(), ""));
+
+ let num_transitions = Arc::new(AtomicU64::new(0));
+
+ let mut stop_threads = false;
+
+ while !stop_threads && !states_to_process_mutex.lock().unwrap().is_empty() {
+ let (mut state, last_op) = Self::next(Arc::clone(&states_to_process_mutex), mc_type);
+
+ let next_states = Self::generateNextStates(&mut state, is_caching, Arc::clone(&num_transitions));
+
+ if !no_inv && !Self::checkInvariants(&state, last_op, is_caching) {
+ println!("INVARIANT VIOLATED");
+ stop_threads = true;
+ }
+ if !no_dead && next_states.is_empty() {
+ print!("DEADLOCK DETECTED");
+ stop_threads = true;
+ }
+
+ next_states.into_iter()
+ .filter(|(next_state, _)| all_states.insert((*next_state).clone()))
+ .for_each(|(next_state, last_op)| states_to_process_mutex.lock().unwrap().push_back((next_state, last_op)));
+
+ if all_states.len() % 50000 == 0 {
+ println!("VISITED STATES: {}", all_states.len());
+ println!("EVALUATED TRANSITIONS: {}", num_transitions.load(Ordering::Acquire));
+ println!("-------------------");
+ }
+ }
+ Self::print_result(all_states.len(), num_transitions.load(Ordering::Acquire), stop_threads);
+ }
+
+ fn modelCheckMultiThreaded(mc_type: MC_TYPE, threads: usize, is_caching: bool, no_dead: bool, no_inv: bool) {
+ let threadPool = ThreadPool::new(threads);
+
+ let machine = LandingGear_R6::new();
+
+ let all_states = Arc::new(DashSet::<LandingGear_R6>::new());
+ all_states.insert(machine.clone());
+
+ let states_to_process_mutex = Arc::new(Mutex::new(LinkedList::<(LandingGear_R6, &'static str)>::new()));
+ states_to_process_mutex.lock().unwrap().push_back((machine, ""));
+
+ let num_transitions = Arc::new(AtomicU64::new(0));
+
+ let mut stop_threads = false;
+ let mut spawned_tasks: u64 = 0;
+ let mut finished_tasks: u64 = 0;
+
+ let (tx, rx) = channel();
+ //println!("Thread {:?} starting threads", thread::current().id());
+ while !stop_threads && !states_to_process_mutex.lock().unwrap().is_empty() {
+ let (mut state, last_op) = Self::next(Arc::clone(&states_to_process_mutex), mc_type);
+
+ let states_to_process = Arc::clone(&states_to_process_mutex);
+ let transitions = Arc::clone(&num_transitions);
+ let states = Arc::clone(&all_states);
+ let tx = tx.clone();
+ //println!("Thread {:?} spawning a thread", thread::current().id());
+ threadPool.execute(move|| {
+ let next_states = Self::generateNextStates(&mut state, is_caching, transitions);
+ if !no_dead && next_states.is_empty() { let _ = tx.send(Err("DEADLOCK DETECTED")); }
+
+ //println!("Thread {:?} executing", thread::current().id());
+ next_states.into_iter()
+ .filter(|(next_state, _)| states.insert((*next_state).clone()))
+ .for_each(|(next_state, last_op)| states_to_process.lock().unwrap().push_back((next_state, last_op)));
+
+ if !no_inv && !Self::checkInvariants(&state, last_op, is_caching) {
+ let _ = tx.send(Err("INVARIANT VIOLATED"));
+ }
+ //println!("Thread {:?} done", thread::current().id());
+ let _ = tx.send(Ok(1));
+ });
+
+ spawned_tasks += 1;
+ if spawned_tasks % 50000 == 0 {
+ println!("VISITED STATES: {}", all_states.len());
+ println!("EVALUATED TRANSITIONS: {}", num_transitions.load(Ordering::Acquire));
+ println!("-------------------");
+ }
+
+ while states_to_process_mutex.lock().unwrap().is_empty() && spawned_tasks - finished_tasks > 0 {
+ //println!("Thread {:?} (main) waiting for a thread to finish", thread::current().id());
+ match rx.try_recv() {
+ Ok(val) => match val {
+ Ok(_) => finished_tasks += 1,
+ Err(msg) => { println!("{}", msg); stop_threads = true; },
+ },
+ Err(_) => (),
+ }
+ if threadPool.panic_count() > 0 { stop_threads = true; }
+ }
+ }
+
+ Self::print_result(all_states.len(), num_transitions.load(Ordering::Acquire), stop_threads);
+ }
+
+}
+
+
+fn main() {
+ let args: Vec<String> = env::args().collect();
+ if args.len() < 4 { panic!("Number of arguments errorneous"); }
+
+ let threads = args.get(2).unwrap().parse::<usize>().unwrap();
+ if threads <= 0 { panic!("Input for number of threads is wrong."); }
+
+ let is_caching = args.get(3).unwrap().parse::<bool>().unwrap();
+ let mc_type = match args.get(1).unwrap().as_str() {
+ "mixed" => MC_TYPE::MIXED,
+ "bf" => MC_TYPE::BFS,
+ "df" => MC_TYPE::DFS,
+ _ => panic!("Input for strategy is wrong.")
+ };
+
+ let mut no_dead = false;
+ let mut no_inv = false;
+
+ if args.len() > 4 {
+ for arg in args.iter().skip(4) {
+ match arg.as_str() {
+ "-nodead" => no_dead = true,
+ "-noinv" => no_inv = true,
+ _ => {}
+ }
+ }
+ }
+
+ if threads == 1 {
+ LandingGear_R6::model_check_single_threaded(mc_type, is_caching, no_dead, no_inv);
+ } else {
+ LandingGear_R6::modelCheckMultiThreaded(mc_type, threads, is_caching, no_dead, no_inv);
+ }
+}
diff --git a/benchmarks/model_checking/Rust_embedded/Lift_MC_Large.rs b/benchmarks/model_checking/Rust_embedded/Lift_MC_Large.rs
new file mode 100644
index 000000000..a04b0aa0e
--- /dev/null
+++ b/benchmarks/model_checking/Rust_embedded/Lift_MC_Large.rs
@@ -0,0 +1,354 @@
+#![ allow( dead_code, unused, non_snake_case, non_camel_case_types, unused_assignments ) ]
+//#![no_std] //std is enabled for the generated machine by default, since without it there is no println which makes unit-testing very difficult
+use btypes::{bset, brel};
+use btypes::bset::BSet;
+use btypes::bset::SetItem;
+use btypes::bset::PowSetItem;
+use btypes::bset::PowAble;
+use btypes::bset::NestedSet;
+use btypes::brelation::BRelation;
+use btypes::brelation::RelLeftItem;
+use btypes::brelation::RelPowAble;
+use btypes::bboolean::BBoolean;
+use btypes::bboolean::BBool;
+use btypes::bboolean::BOOL;
+use btypes::binteger::BInteger;
+use btypes::binteger::BInt;
+use btypes::binteger::set_BInteger;
+use btypes::btuple::BTuple;
+
+use std::env;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, mpsc, Mutex};
+use std::collections::{HashSet, LinkedList};
+use dashmap::DashSet;
+use threadpool::ThreadPool;
+use std::sync::mpsc::channel;
+use derivative::Derivative;
+use std::time::{Duration};
+
+
+
+#[derive(Clone, Copy)]
+pub enum MC_TYPE { BFS, DFS, MIXED }
+
+
+
+
+#[derive(Derivative)]
+#[derivative(Clone, Default, Debug, Hash, PartialEq, Eq)]
+pub struct Lift_MC_Large {
+ /*declarations*/level: BInteger,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_inc: Option<bool>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_dec: Option<bool>,}
+
+
+impl Lift_MC_Large {
+
+ pub fn new() -> Lift_MC_Large {
+ //values: ''
+ let mut m: Lift_MC_Large = Default::default();
+ m.init();
+ return m;
+ }
+ fn init(&mut self) {
+ /*set_initializations*/
+ /*properties*/
+ /*body*/self.level = 0;
+ /*includesInitialization*/
+ }
+
+ pub fn get_level(&self) -> BInteger {
+ return self.level.clone();
+ }
+
+ pub fn inc(&mut self) -> () {
+ //pre_assert
+ self.level = self.level.plus(&1);
+
+ }
+
+ pub fn dec(&mut self) -> () {
+ //pre_assert
+ self.level = self.level.minus(&1);
+
+ }
+
+ pub fn _tr_inc(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_inc.is_none() {
+ let mut __tmp__val__ = self.level.less(&1000000);
+ self._tr_cache_inc = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_inc.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_dec(&mut self, is_caching: bool) -> bool {
+ //transition
+ if !is_caching || self._tr_cache_dec.is_none() {
+ let mut __tmp__val__ = self.level.greater(&0);
+ self._tr_cache_dec = Option::Some(__tmp__val__);
+ return __tmp__val__;
+ } else {
+ return self._tr_cache_dec.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _check_inv_1(&self) -> bool {
+ //invariant
+ return self.level.greaterEqual(&0);
+ }
+
+ pub fn _check_inv_2(&self) -> bool {
+ //invariant
+ return self.level.lessEqual(&1000000);
+ }
+
+ fn invalidate_caches(&mut self, to_invalidate: Vec<&'static str>) {
+ //calling the given functions without caching will recalculate them and cache them afterwards
+ for trans in to_invalidate {
+ match trans {
+ "_tr_inc" => {self._tr_inc(false);},
+ "_tr_dec" => {self._tr_dec(false);},
+ _ => {},
+ }
+ }
+ }
+
+ //model_check_next_states
+ fn generateNextStates(state: &mut Lift_MC_Large,
+ isCaching: bool,
+ transitions: Arc<AtomicU64>) -> HashSet<(Lift_MC_Large, &'static str)> {
+ let mut result = HashSet::<(Lift_MC_Large, &'static str)>::new();
+ let mut evaluated_transitions: u64 = 0;
+ //model_check_transition
+ if state._tr_inc(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.inc();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("inc")); }
+ result.insert((copiedState, "inc"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ if state._tr_dec(isCaching) {
+ //model_check_transition_body
+ let mut copiedState = state.clone();
+ copiedState.dec();
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("dec")); }
+ result.insert((copiedState, "dec"));
+ evaluated_transitions += 1;
+ }
+
+
+ transitions.fetch_add(evaluated_transitions, Ordering::AcqRel);
+ return result;
+ }
+
+ //model_check_invariants
+ pub fn checkInvariants(state: &Lift_MC_Large, last_op: &'static str, isCaching: bool) -> bool {
+ if isCaching {
+ let dependent_invariants_of_state = Self::get_invariant_dependencies(last_op);
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_1") {
+ if !state._check_inv_1() {
+ println!("_check_inv_1 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_2") {
+ if !state._check_inv_2() {
+ println!("_check_inv_2 failed!");
+ return false;
+ }
+ }
+ return true;
+ }
+ return !(!state._check_inv_1() || !state._check_inv_2());
+ }
+
+ //model_check_print
+ fn print_result(states: usize, transitions: u64, error_detected: bool) {
+ if !error_detected { println!("MODEL CHECKING SUCCESSFUL"); }
+ println!("Number of States: {}", states);
+ println!("Number of Transitions: {}", transitions);
+ }
+
+ //model_check_main
+ fn next(collection_m: Arc<Mutex<LinkedList<(Lift_MC_Large, &'static str)>>>, mc_type: MC_TYPE) -> (Lift_MC_Large, &'static str) {
+ let mut collection = collection_m.lock().unwrap();
+ return match mc_type {
+ MC_TYPE::BFS => collection.pop_front().unwrap(),
+ MC_TYPE::DFS => collection.pop_back().unwrap(),
+ MC_TYPE::MIXED => if collection.len() % 2 == 0 { collection.pop_front().unwrap() } else { collection.pop_back().unwrap() }
+ };
+ }
+
+ fn get_guard_dependencies(op: &'static str) -> Vec<&str> {
+ return match op {
+ //model_check_init_static
+ "dec" => vec!["_tr_dec", "_tr_inc"],
+ //model_check_init_static
+ "inc" => vec!["_tr_dec", "_tr_inc"],
+ _ => vec![],
+ }
+ }
+
+ fn get_invariant_dependencies(op: &'static str) -> Vec<&str> {
+ return match op {
+ //model_check_init_static
+ "dec" => vec!["_check_inv_2", "_check_inv_1"],
+ //model_check_init_static
+ "inc" => vec!["_check_inv_2", "_check_inv_1"],
+ _ => vec![],
+ }
+ }
+
+ fn model_check_single_threaded(mc_type: MC_TYPE, is_caching: bool, no_dead: bool, no_inv: bool) {
+ let mut machine = Lift_MC_Large::new();
+
+ let mut all_states = HashSet::<Lift_MC_Large>::new();
+ all_states.insert(machine.clone());
+
+ let states_to_process_mutex = Arc::new(Mutex::new(LinkedList::<(Lift_MC_Large, &'static str)>::new()));
+ states_to_process_mutex.lock().unwrap().push_back((machine.clone(), ""));
+
+ let num_transitions = Arc::new(AtomicU64::new(0));
+
+ let mut stop_threads = false;
+
+ while !stop_threads && !states_to_process_mutex.lock().unwrap().is_empty() {
+ let (mut state, last_op) = Self::next(Arc::clone(&states_to_process_mutex), mc_type);
+
+ let next_states = Self::generateNextStates(&mut state, is_caching, Arc::clone(&num_transitions));
+
+ if !no_inv && !Self::checkInvariants(&state, last_op, is_caching) {
+ println!("INVARIANT VIOLATED");
+ stop_threads = true;
+ }
+ if !no_dead && next_states.is_empty() {
+ print!("DEADLOCK DETECTED");
+ stop_threads = true;
+ }
+
+ next_states.into_iter()
+ .filter(|(next_state, _)| all_states.insert((*next_state).clone()))
+ .for_each(|(next_state, last_op)| states_to_process_mutex.lock().unwrap().push_back((next_state, last_op)));
+
+ if all_states.len() % 50000 == 0 {
+ println!("VISITED STATES: {}", all_states.len());
+ println!("EVALUATED TRANSITIONS: {}", num_transitions.load(Ordering::Acquire));
+ println!("-------------------");
+ }
+ }
+ Self::print_result(all_states.len(), num_transitions.load(Ordering::Acquire), stop_threads);
+ }
+
+ fn modelCheckMultiThreaded(mc_type: MC_TYPE, threads: usize, is_caching: bool, no_dead: bool, no_inv: bool) {
+ let threadPool = ThreadPool::new(threads);
+
+ let machine = Lift_MC_Large::new();
+
+ let all_states = Arc::new(DashSet::<Lift_MC_Large>::new());
+ all_states.insert(machine.clone());
+
+ let states_to_process_mutex = Arc::new(Mutex::new(LinkedList::<(Lift_MC_Large, &'static str)>::new()));
+ states_to_process_mutex.lock().unwrap().push_back((machine, ""));
+
+ let num_transitions = Arc::new(AtomicU64::new(0));
+
+ let mut stop_threads = false;
+ let mut spawned_tasks: u64 = 0;
+ let mut finished_tasks: u64 = 0;
+
+ let (tx, rx) = channel();
+ //println!("Thread {:?} starting threads", thread::current().id());
+ while !stop_threads && !states_to_process_mutex.lock().unwrap().is_empty() {
+ let (mut state, last_op) = Self::next(Arc::clone(&states_to_process_mutex), mc_type);
+
+ let states_to_process = Arc::clone(&states_to_process_mutex);
+ let transitions = Arc::clone(&num_transitions);
+ let states = Arc::clone(&all_states);
+ let tx = tx.clone();
+ //println!("Thread {:?} spawning a thread", thread::current().id());
+ threadPool.execute(move|| {
+ let next_states = Self::generateNextStates(&mut state, is_caching, transitions);
+ if !no_dead && next_states.is_empty() { let _ = tx.send(Err("DEADLOCK DETECTED")); }
+
+ //println!("Thread {:?} executing", thread::current().id());
+ next_states.into_iter()
+ .filter(|(next_state, _)| states.insert((*next_state).clone()))
+ .for_each(|(next_state, last_op)| states_to_process.lock().unwrap().push_back((next_state, last_op)));
+
+ if !no_inv && !Self::checkInvariants(&state, last_op, is_caching) {
+ let _ = tx.send(Err("INVARIANT VIOLATED"));
+ }
+ //println!("Thread {:?} done", thread::current().id());
+ let _ = tx.send(Ok(1));
+ });
+
+ spawned_tasks += 1;
+ if spawned_tasks % 50000 == 0 {
+ println!("VISITED STATES: {}", all_states.len());
+ println!("EVALUATED TRANSITIONS: {}", num_transitions.load(Ordering::Acquire));
+ println!("-------------------");
+ }
+
+ while states_to_process_mutex.lock().unwrap().is_empty() && spawned_tasks - finished_tasks > 0 {
+ //println!("Thread {:?} (main) waiting for a thread to finish", thread::current().id());
+ match rx.try_recv() {
+ Ok(val) => match val {
+ Ok(_) => finished_tasks += 1,
+ Err(msg) => { println!("{}", msg); stop_threads = true; },
+ },
+ Err(_) => (),
+ }
+ if threadPool.panic_count() > 0 { stop_threads = true; }
+ }
+ }
+
+ Self::print_result(all_states.len(), num_transitions.load(Ordering::Acquire), stop_threads);
+ }
+
+}
+
+
+fn main() {
+ let args: Vec<String> = env::args().collect();
+ if args.len() < 4 { panic!("Number of arguments errorneous"); }
+
+ let threads = args.get(2).unwrap().parse::<usize>().unwrap();
+ if threads <= 0 { panic!("Input for number of threads is wrong."); }
+
+ let is_caching = args.get(3).unwrap().parse::<bool>().unwrap();
+ let mc_type = match args.get(1).unwrap().as_str() {
+ "mixed" => MC_TYPE::MIXED,
+ "bf" => MC_TYPE::BFS,
+ "df" => MC_TYPE::DFS,
+ _ => panic!("Input for strategy is wrong.")
+ };
+
+ let mut no_dead = false;
+ let mut no_inv = false;
+
+ if args.len() > 4 {
+ for arg in args.iter().skip(4) {
+ match arg.as_str() {
+ "-nodead" => no_dead = true,
+ "-noinv" => no_inv = true,
+ _ => {}
+ }
+ }
+ }
+
+ if threads == 1 {
+ Lift_MC_Large::model_check_single_threaded(mc_type, is_caching, no_dead, no_inv);
+ } else {
+ Lift_MC_Large::modelCheckMultiThreaded(mc_type, threads, is_caching, no_dead, no_inv);
+ }
+}
diff --git a/benchmarks/model_checking/Rust_embedded/Makefile b/benchmarks/model_checking/Rust_embedded/Makefile
new file mode 100644
index 000000000..15291912b
--- /dev/null
+++ b/benchmarks/model_checking/Rust_embedded/Makefile
@@ -0,0 +1,32 @@
+.SUFFIXES:
+
+.PHONY: all clean
+
+all: Lift_MC_Large Cruise_finite1_deterministic_MC LandingGear_R6 CAN_BUS_tlc Train1_Lukas_POR_v3 Train_1_beebook_deterministic_MC_POR_v2 nota_v2
+
+OUTPUT ?= runtimes.txt
+
+CARGO_PROJ_PATH=../../../btypes_primitives/src/main/rust_embedded/bmachine_mc
+#CARGO_PROJ_PATH=../../../btypes_primitives/src/main/rust_embedded/bmachine_bitvec_mc
+CARGO_BUILD=cargo build --release --manifest-path $(CARGO_PROJ_PATH)/Cargo.toml
+#CARGO_BUILD=cargo +nightly build --release --manifest-path $(CARGO_PROJ_PATH)/Cargo.toml
+STRATEGY=mixed
+THREADS=1
+CACHING=true
+
+% : clean %.rs
+ cp $(*).rs $(CARGO_PROJ_PATH)/src/main.rs
+ $(CARGO_BUILD)
+ /usr/bin/time -f "$(*) %E %M" -ao $(OUTPUT) $(CARGO_PROJ_PATH)/target/release/bmachine_mc $(STRATEGY) $(THREADS) $(CACHING)
+ /usr/bin/time -f "$(*) %E %M" -ao $(OUTPUT) $(CARGO_PROJ_PATH)/target/release/bmachine_mc $(STRATEGY) $(THREADS) $(CACHING)
+ /usr/bin/time -f "$(*) %E %M" -ao $(OUTPUT) $(CARGO_PROJ_PATH)/target/release/bmachine_mc $(STRATEGY) $(THREADS) $(CACHING)
+ /usr/bin/time -f "$(*) %E %M" -ao $(OUTPUT) $(CARGO_PROJ_PATH)/target/release/bmachine_mc $(STRATEGY) $(THREADS) $(CACHING)
+ /usr/bin/time -f "$(*) %E %M" -ao $(OUTPUT) $(CARGO_PROJ_PATH)/target/release/bmachine_mc $(STRATEGY) $(THREADS) $(CACHING)
+ /usr/bin/time -f "$(*) %E %M" -ao $(OUTPUT) $(CARGO_PROJ_PATH)/target/release/bmachine_mc $(STRATEGY) $(THREADS) $(CACHING)
+ /usr/bin/time -f "$(*) %E %M" -ao $(OUTPUT) $(CARGO_PROJ_PATH)/target/release/bmachine_mc $(STRATEGY) $(THREADS) $(CACHING)
+ /usr/bin/time -f "$(*) %E %M" -ao $(OUTPUT) $(CARGO_PROJ_PATH)/target/release/bmachine_mc $(STRATEGY) $(THREADS) $(CACHING)
+ /usr/bin/time -f "$(*) %E %M" -ao $(OUTPUT) $(CARGO_PROJ_PATH)/target/release/bmachine_mc $(STRATEGY) $(THREADS) $(CACHING)
+ /usr/bin/time -f "$(*) %E %M" -ao $(OUTPUT) $(CARGO_PROJ_PATH)/target/release/bmachine_mc $(STRATEGY) $(THREADS) $(CACHING)
+
+clean:
+ rm -f $(CARGO_PROJ_PATH)/src/*.rs
\ No newline at end of file
diff --git a/benchmarks/model_checking/Rust_embedded/Train1_Lukas_POR_v3.rs b/benchmarks/model_checking/Rust_embedded/Train1_Lukas_POR_v3.rs
new file mode 100644
index 000000000..3bc572a92
--- /dev/null
+++ b/benchmarks/model_checking/Rust_embedded/Train1_Lukas_POR_v3.rs
@@ -0,0 +1,1386 @@
+#![ allow( dead_code, unused, non_snake_case, non_camel_case_types, unused_assignments ) ]
+//#![no_std] //std is enabled for the generated machine by default, since without it there is no println which makes unit-testing very difficult
+use btypes::{bset, brel};
+use btypes::bset::BSet;
+use btypes::bset::SetItem;
+use btypes::bset::PowSetItem;
+use btypes::bset::PowAble;
+use btypes::bset::NestedSet;
+use btypes::brelation::BRelation;
+use btypes::brelation::RelLeftItem;
+use btypes::brelation::RelPowAble;
+use btypes::bboolean::BBoolean;
+use btypes::bboolean::BBool;
+use btypes::bboolean::BOOL;
+use btypes::binteger::BInteger;
+use btypes::binteger::BInt;
+use btypes::binteger::set_BInteger;
+use btypes::btuple::BTuple;
+
+use std::env;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, mpsc, Mutex};
+use std::collections::{HashSet, LinkedList};
+use dashmap::DashSet;
+use threadpool::ThreadPool;
+use std::sync::mpsc::channel;
+use derivative::Derivative;
+use std::time::{Duration};
+
+
+
+#[derive(Clone, Copy)]
+pub enum MC_TYPE { BFS, DFS, MIXED }
+
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum BLOCKS {
+ #[default]
+ A = 0,
+ B = 1,
+ C = 2,
+ D = 3,
+ E = 4,
+ F = 5,
+ G = 6,
+ H = 7,
+ I = 8
+}
+
+impl BLOCKS {
+ pub fn equal(&self, other: &BLOCKS) -> bool { *self == *other }
+ pub fn unequal(&self, other: &BLOCKS) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::A,
+ 1 => Self::B,
+ 2 => Self::C,
+ 3 => Self::D,
+ 4 => Self::E,
+ 5 => Self::F,
+ 6 => Self::G,
+ 7 => Self::H,
+ 8 => Self::I,
+ _ => panic!("BLOCKS index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<9> for BLOCKS {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_BLOCKS = BSet<BLOCKS, 9>;
+//set_enum_declaration done
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum ROUTES {
+ #[default]
+ R1 = 0,
+ R2 = 1,
+ R3 = 2,
+ R4 = 3,
+ R5 = 4,
+ R6 = 5,
+ R7 = 6,
+ R8 = 7
+}
+
+impl ROUTES {
+ pub fn equal(&self, other: &ROUTES) -> bool { *self == *other }
+ pub fn unequal(&self, other: &ROUTES) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::R1,
+ 1 => Self::R2,
+ 2 => Self::R3,
+ 3 => Self::R4,
+ 4 => Self::R5,
+ 5 => Self::R6,
+ 6 => Self::R7,
+ 7 => Self::R8,
+ _ => panic!("ROUTES index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<8> for ROUTES {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_ROUTES = BSet<ROUTES, 8>;
+//set_enum_declaration done
+
+//relation_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum BLOCKS_X_BLOCKS {
+ #[default]
+ A_A = 0,
+ A_B = 1,
+ A_C = 2,
+ A_D = 3,
+ A_E = 4,
+ A_F = 5,
+ A_G = 6,
+ A_H = 7,
+ A_I = 8,
+ B_A = 9,
+ B_B = 10,
+ B_C = 11,
+ B_D = 12,
+ B_E = 13,
+ B_F = 14,
+ B_G = 15,
+ B_H = 16,
+ B_I = 17,
+ C_A = 18,
+ C_B = 19,
+ C_C = 20,
+ C_D = 21,
+ C_E = 22,
+ C_F = 23,
+ C_G = 24,
+ C_H = 25,
+ C_I = 26,
+ D_A = 27,
+ D_B = 28,
+ D_C = 29,
+ D_D = 30,
+ D_E = 31,
+ D_F = 32,
+ D_G = 33,
+ D_H = 34,
+ D_I = 35,
+ E_A = 36,
+ E_B = 37,
+ E_C = 38,
+ E_D = 39,
+ E_E = 40,
+ E_F = 41,
+ E_G = 42,
+ E_H = 43,
+ E_I = 44,
+ F_A = 45,
+ F_B = 46,
+ F_C = 47,
+ F_D = 48,
+ F_E = 49,
+ F_F = 50,
+ F_G = 51,
+ F_H = 52,
+ F_I = 53,
+ G_A = 54,
+ G_B = 55,
+ G_C = 56,
+ G_D = 57,
+ G_E = 58,
+ G_F = 59,
+ G_G = 60,
+ G_H = 61,
+ G_I = 62,
+ H_A = 63,
+ H_B = 64,
+ H_C = 65,
+ H_D = 66,
+ H_E = 67,
+ H_F = 68,
+ H_G = 69,
+ H_H = 70,
+ H_I = 71,
+ I_A = 72,
+ I_B = 73,
+ I_C = 74,
+ I_D = 75,
+ I_E = 76,
+ I_F = 77,
+ I_G = 78,
+ I_H = 79,
+ I_I = 80
+}
+type rel_BLOCKS_X_BLOCKS = BRelation<BLOCKS, { BLOCKS::VARIANTS }, BLOCKS, { BLOCKS::VARIANTS }, 81>;
+//relation_declaration done
+
+
+
+//relation_declaration
+type rel_ROUTES_X_SetBLOCKS_X_BLOCKS = BRelation<ROUTES, { ROUTES::VARIANTS }, rel_BLOCKS_X_BLOCKS, { rel_BLOCKS_X_BLOCKS::VARIANTS }, 0>;
+//relation_declaration done
+
+
+
+//enum_set_declaration start
+#[derive(Default, Debug, Clone, Copy)]
+// each enum value corresponds to one BSet
+pub enum SetBLOCKS_X_BLOCKS {
+ #[default]
+ SET_SET_A_B__B_C_TES_TES = 0,
+ SET_SET_A_B__B_D__D_E__E_F_TES_TES = 1,
+ SET_SET_E_F__G_E__H_G_TES_TES = 2,
+ SET_SET_E_F__G_E__I_G_TES_TES = 3,
+ SET_SET_B_A__C_B_TES_TES = 4,
+ SET_SET_B_A__D_B__E_D__F_E_TES_TES = 5,
+ SET_SET_E_G__F_E__G_H_TES_TES = 6,
+ SET_SET_E_G__F_E__G_I_TES_TES = 7
+}
+type set_SetBLOCKS_X_BLOCKS = BSet<rel_BLOCKS_X_BLOCKS, 8>;
+
+impl PowSetItem<8, 81> for BLOCKS_X_BLOCKS {
+ type SetRepr = SetBLOCKS_X_BLOCKS;
+ fn arr_to_idx(set: [bool; 81]) -> usize {
+ match set {
+ [false, true, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false] => 0,
+ [false, true, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false] => 1,
+ [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false] => 2,
+ [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false] => 3,
+ [false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false] => 4,
+ [false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false] => 5,
+ [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false] => 6,
+ [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false] => 7,
+ _ => panic!("Attempting to convert non-existing set to index!") // only happens if this is a const-set and code-generation missed a necessary value
+ }
+ }
+ fn idx_to_arr(idx: usize) -> [bool; 81] {
+ match idx {
+ 0 => [false, true, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false],
+ 1 => [false, true, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false],
+ 2 => [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false],
+ 3 => [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false],
+ 4 => [false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false],
+ 5 => [false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false],
+ 6 => [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false],
+ 7 => [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false],
+ _ => panic!("SetBLOCKS_X_BLOCKS index out of range! {:?}", idx)
+ }
+ }
+}
+impl RelLeftItem<{BLOCKS::VARIANTS}, BLOCKS, { BLOCKS::VARIANTS}, 8, 81> for BLOCKS {
+ type RelEnum = BLOCKS_X_BLOCKS;
+}
+impl SetBLOCKS_X_BLOCKS {
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::SET_SET_A_B__B_C_TES_TES,
+ 1 => Self::SET_SET_A_B__B_D__D_E__E_F_TES_TES,
+ 2 => Self::SET_SET_E_F__G_E__H_G_TES_TES,
+ 3 => Self::SET_SET_E_F__G_E__I_G_TES_TES,
+ 4 => Self::SET_SET_B_A__C_B_TES_TES,
+ 5 => Self::SET_SET_B_A__D_B__E_D__F_E_TES_TES,
+ 6 => Self::SET_SET_E_G__F_E__G_H_TES_TES,
+ 7 => Self::SET_SET_E_G__F_E__G_I_TES_TES,
+ _ => panic!("SetBLOCKS_X_BLOCKS index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<8> for SetBLOCKS_X_BLOCKS {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+//enum_set_declaration done
+
+//relation_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum ROUTES_X_BLOCKS {
+ #[default]
+ R1_A = 0,
+ R1_B = 1,
+ R1_C = 2,
+ R1_D = 3,
+ R1_E = 4,
+ R1_F = 5,
+ R1_G = 6,
+ R1_H = 7,
+ R1_I = 8,
+ R2_A = 9,
+ R2_B = 10,
+ R2_C = 11,
+ R2_D = 12,
+ R2_E = 13,
+ R2_F = 14,
+ R2_G = 15,
+ R2_H = 16,
+ R2_I = 17,
+ R3_A = 18,
+ R3_B = 19,
+ R3_C = 20,
+ R3_D = 21,
+ R3_E = 22,
+ R3_F = 23,
+ R3_G = 24,
+ R3_H = 25,
+ R3_I = 26,
+ R4_A = 27,
+ R4_B = 28,
+ R4_C = 29,
+ R4_D = 30,
+ R4_E = 31,
+ R4_F = 32,
+ R4_G = 33,
+ R4_H = 34,
+ R4_I = 35,
+ R5_A = 36,
+ R5_B = 37,
+ R5_C = 38,
+ R5_D = 39,
+ R5_E = 40,
+ R5_F = 41,
+ R5_G = 42,
+ R5_H = 43,
+ R5_I = 44,
+ R6_A = 45,
+ R6_B = 46,
+ R6_C = 47,
+ R6_D = 48,
+ R6_E = 49,
+ R6_F = 50,
+ R6_G = 51,
+ R6_H = 52,
+ R6_I = 53,
+ R7_A = 54,
+ R7_B = 55,
+ R7_C = 56,
+ R7_D = 57,
+ R7_E = 58,
+ R7_F = 59,
+ R7_G = 60,
+ R7_H = 61,
+ R7_I = 62,
+ R8_A = 63,
+ R8_B = 64,
+ R8_C = 65,
+ R8_D = 66,
+ R8_E = 67,
+ R8_F = 68,
+ R8_G = 69,
+ R8_H = 70,
+ R8_I = 71
+}
+type rel_ROUTES_X_BLOCKS = BRelation<ROUTES, { ROUTES::VARIANTS }, BLOCKS, { BLOCKS::VARIANTS }, 72>;
+//relation_declaration done
+
+//relation_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum BLOCKS_X_ROUTES {
+ #[default]
+ A_R1 = 0,
+ A_R2 = 1,
+ A_R3 = 2,
+ A_R4 = 3,
+ A_R5 = 4,
+ A_R6 = 5,
+ A_R7 = 6,
+ A_R8 = 7,
+ B_R1 = 8,
+ B_R2 = 9,
+ B_R3 = 10,
+ B_R4 = 11,
+ B_R5 = 12,
+ B_R6 = 13,
+ B_R7 = 14,
+ B_R8 = 15,
+ C_R1 = 16,
+ C_R2 = 17,
+ C_R3 = 18,
+ C_R4 = 19,
+ C_R5 = 20,
+ C_R6 = 21,
+ C_R7 = 22,
+ C_R8 = 23,
+ D_R1 = 24,
+ D_R2 = 25,
+ D_R3 = 26,
+ D_R4 = 27,
+ D_R5 = 28,
+ D_R6 = 29,
+ D_R7 = 30,
+ D_R8 = 31,
+ E_R1 = 32,
+ E_R2 = 33,
+ E_R3 = 34,
+ E_R4 = 35,
+ E_R5 = 36,
+ E_R6 = 37,
+ E_R7 = 38,
+ E_R8 = 39,
+ F_R1 = 40,
+ F_R2 = 41,
+ F_R3 = 42,
+ F_R4 = 43,
+ F_R5 = 44,
+ F_R6 = 45,
+ F_R7 = 46,
+ F_R8 = 47,
+ G_R1 = 48,
+ G_R2 = 49,
+ G_R3 = 50,
+ G_R4 = 51,
+ G_R5 = 52,
+ G_R6 = 53,
+ G_R7 = 54,
+ G_R8 = 55,
+ H_R1 = 56,
+ H_R2 = 57,
+ H_R3 = 58,
+ H_R4 = 59,
+ H_R5 = 60,
+ H_R6 = 61,
+ H_R7 = 62,
+ H_R8 = 63,
+ I_R1 = 64,
+ I_R2 = 65,
+ I_R3 = 66,
+ I_R4 = 67,
+ I_R5 = 68,
+ I_R6 = 69,
+ I_R7 = 70,
+ I_R8 = 71
+}
+type rel_BLOCKS_X_ROUTES = BRelation<BLOCKS, { BLOCKS::VARIANTS }, ROUTES, { ROUTES::VARIANTS }, 72>;
+//relation_declaration done
+
+#[derive(Derivative)]
+#[derivative(Clone, Default, Debug, Hash, PartialEq, Eq)]
+pub struct Train1_Lukas_POR_v3 {
+ /*declarations*/LBT: set_BLOCKS,
+ TRK: rel_BLOCKS_X_BLOCKS,
+ frm: set_ROUTES,
+ OCC: set_BLOCKS,
+ resbl: set_BLOCKS,
+ resrt: set_ROUTES,
+ rsrtbl: rel_BLOCKS_X_ROUTES,
+ /*constant_declarations*/fst: rel_ROUTES_X_BLOCKS,
+ lst: rel_ROUTES_X_BLOCKS,
+ nxt: rel_ROUTES_X_SetBLOCKS_X_BLOCKS,
+ rtbl: rel_BLOCKS_X_ROUTES,
+ /*sets*//*set_declaration*/_BLOCKS: set_BLOCKS,
+ /*set_declaration*/_ROUTES: set_ROUTES,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_route_reservation: Option<HashSet<ROUTES>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_route_freeing: Option<HashSet<ROUTES>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_FRONT_MOVE_1: Option<HashSet<ROUTES>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_FRONT_MOVE_2: Option<HashSet<BLOCKS>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_BACK_MOVE_1: Option<HashSet<BLOCKS>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_BACK_MOVE_2: Option<HashSet<BLOCKS>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_point_positionning: Option<HashSet<ROUTES>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_route_formation: Option<HashSet<ROUTES>>,}
+
+
+impl Train1_Lukas_POR_v3 {
+
+ pub fn new() -> Train1_Lukas_POR_v3 {
+ //values: ''
+ let mut m: Train1_Lukas_POR_v3 = Default::default();
+ m.init();
+ return m;
+ }
+ fn init(&mut self) {
+ /*set_initializations*///set_initialization
+ self._BLOCKS = bset![BLOCKS, /*enum_call*/BLOCKS::A, /*enum_call*/BLOCKS::B, /*enum_call*/BLOCKS::C, /*enum_call*/BLOCKS::D, /*enum_call*/BLOCKS::E, /*enum_call*/BLOCKS::F, /*enum_call*/BLOCKS::G, /*enum_call*/BLOCKS::H, /*enum_call*/BLOCKS::I];
+ //set_initialization
+ self._ROUTES = bset![ROUTES, /*enum_call*/ROUTES::R1, /*enum_call*/ROUTES::R2, /*enum_call*/ROUTES::R3, /*enum_call*/ROUTES::R4, /*enum_call*/ROUTES::R5, /*enum_call*/ROUTES::R6, /*enum_call*/ROUTES::R7, /*enum_call*/ROUTES::R8];
+ /*properties*///constant_initialization
+ self.nxt = brel![rel_ROUTES_X_SetBLOCKS_X_BLOCKS, (/*enum_call*/ROUTES::R1.clone(), brel![rel_BLOCKS_X_BLOCKS, (/*enum_call*/BLOCKS::A.clone(), /*enum_call*/BLOCKS::B.clone()), (/*enum_call*/BLOCKS::B.clone(), /*enum_call*/BLOCKS::C.clone())].clone()), (/*enum_call*/ROUTES::R2.clone(), brel![rel_BLOCKS_X_BLOCKS, (/*enum_call*/BLOCKS::A.clone(), /*enum_call*/BLOCKS::B.clone()), (/*enum_call*/BLOCKS::B.clone(), /*enum_call*/BLOCKS::D.clone()), (/*enum_call*/BLOCKS::D.clone(), /*enum_call*/BLOCKS::E.clone()), (/*enum_call*/BLOCKS::E.clone(), /*enum_call*/BLOCKS::F.clone())].clone()), (/*enum_call*/ROUTES::R3.clone(), brel![rel_BLOCKS_X_BLOCKS, (/*enum_call*/BLOCKS::H.clone(), /*enum_call*/BLOCKS::G.clone()), (/*enum_call*/BLOCKS::G.clone(), /*enum_call*/BLOCKS::E.clone()), (/*enum_call*/BLOCKS::E.clone(), /*enum_call*/BLOCKS::F.clone())].clone()), (/*enum_call*/ROUTES::R4.clone(), brel![rel_BLOCKS_X_BLOCKS, (/*enum_call*/BLOCKS::I.clone(), /*enum_call*/BLOCKS::G.clone()), (/*enum_call*/BLOCKS::G.clone(), /*enum_call*/BLOCKS::E.clone()), (/*enum_call*/BLOCKS::E.clone(), /*enum_call*/BLOCKS::F.clone())].clone()), (/*enum_call*/ROUTES::R5.clone(), brel![rel_BLOCKS_X_BLOCKS, (/*enum_call*/BLOCKS::C.clone(), /*enum_call*/BLOCKS::B.clone()), (/*enum_call*/BLOCKS::B.clone(), /*enum_call*/BLOCKS::A.clone())].clone()), (/*enum_call*/ROUTES::R6.clone(), brel![rel_BLOCKS_X_BLOCKS, (/*enum_call*/BLOCKS::F.clone(), /*enum_call*/BLOCKS::E.clone()), (/*enum_call*/BLOCKS::E.clone(), /*enum_call*/BLOCKS::D.clone()), (/*enum_call*/BLOCKS::D.clone(), /*enum_call*/BLOCKS::B.clone()), (/*enum_call*/BLOCKS::B.clone(), /*enum_call*/BLOCKS::A.clone())].clone()), (/*enum_call*/ROUTES::R7.clone(), brel![rel_BLOCKS_X_BLOCKS, (/*enum_call*/BLOCKS::F.clone(), /*enum_call*/BLOCKS::E.clone()), (/*enum_call*/BLOCKS::E.clone(), /*enum_call*/BLOCKS::G.clone()), (/*enum_call*/BLOCKS::G.clone(), /*enum_call*/BLOCKS::H.clone())].clone()), (/*enum_call*/ROUTES::R8.clone(), brel![rel_BLOCKS_X_BLOCKS, (/*enum_call*/BLOCKS::F.clone(), /*enum_call*/BLOCKS::E.clone()), (/*enum_call*/BLOCKS::E.clone(), /*enum_call*/BLOCKS::G.clone()), (/*enum_call*/BLOCKS::G.clone(), /*enum_call*/BLOCKS::I.clone())].clone())];
+ //constant_initialization
+ self.fst = brel![rel_ROUTES_X_BLOCKS, (/*enum_call*/ROUTES::R1.clone(), /*enum_call*/BLOCKS::A.clone()), (/*enum_call*/ROUTES::R2.clone(), /*enum_call*/BLOCKS::A.clone()), (/*enum_call*/ROUTES::R3.clone(), /*enum_call*/BLOCKS::H.clone()), (/*enum_call*/ROUTES::R4.clone(), /*enum_call*/BLOCKS::I.clone()), (/*enum_call*/ROUTES::R5.clone(), /*enum_call*/BLOCKS::C.clone()), (/*enum_call*/ROUTES::R6.clone(), /*enum_call*/BLOCKS::F.clone()), (/*enum_call*/ROUTES::R7.clone(), /*enum_call*/BLOCKS::F.clone()), (/*enum_call*/ROUTES::R8.clone(), /*enum_call*/BLOCKS::F.clone())];
+ //constant_initialization
+ self.lst = brel![rel_ROUTES_X_BLOCKS, (/*enum_call*/ROUTES::R1.clone(), /*enum_call*/BLOCKS::C.clone()), (/*enum_call*/ROUTES::R2.clone(), /*enum_call*/BLOCKS::F.clone()), (/*enum_call*/ROUTES::R3.clone(), /*enum_call*/BLOCKS::F.clone()), (/*enum_call*/ROUTES::R4.clone(), /*enum_call*/BLOCKS::F.clone()), (/*enum_call*/ROUTES::R5.clone(), /*enum_call*/BLOCKS::A.clone()), (/*enum_call*/ROUTES::R6.clone(), /*enum_call*/BLOCKS::A.clone()), (/*enum_call*/ROUTES::R7.clone(), /*enum_call*/BLOCKS::H.clone()), (/*enum_call*/ROUTES::R8.clone(), /*enum_call*/BLOCKS::I.clone())];
+ //constant_initialization
+ self.rtbl = brel![rel_BLOCKS_X_ROUTES, (/*enum_call*/BLOCKS::A.clone(), /*enum_call*/ROUTES::R1.clone()), (/*enum_call*/BLOCKS::A.clone(), /*enum_call*/ROUTES::R2.clone()), (/*enum_call*/BLOCKS::A.clone(), /*enum_call*/ROUTES::R5.clone()), (/*enum_call*/BLOCKS::A.clone(), /*enum_call*/ROUTES::R6.clone()), (/*enum_call*/BLOCKS::B.clone(), /*enum_call*/ROUTES::R1.clone()), (/*enum_call*/BLOCKS::B.clone(), /*enum_call*/ROUTES::R2.clone()), (/*enum_call*/BLOCKS::B.clone(), /*enum_call*/ROUTES::R5.clone()), (/*enum_call*/BLOCKS::B.clone(), /*enum_call*/ROUTES::R6.clone()), (/*enum_call*/BLOCKS::C.clone(), /*enum_call*/ROUTES::R1.clone()), (/*enum_call*/BLOCKS::C.clone(), /*enum_call*/ROUTES::R5.clone()), (/*enum_call*/BLOCKS::D.clone(), /*enum_call*/ROUTES::R2.clone()), (/*enum_call*/BLOCKS::D.clone(), /*enum_call*/ROUTES::R6.clone()), (/*enum_call*/BLOCKS::E.clone(), /*enum_call*/ROUTES::R2.clone()), (/*enum_call*/BLOCKS::E.clone(), /*enum_call*/ROUTES::R3.clone()), (/*enum_call*/BLOCKS::E.clone(), /*enum_call*/ROUTES::R4.clone()), (/*enum_call*/BLOCKS::E.clone(), /*enum_call*/ROUTES::R6.clone()), (/*enum_call*/BLOCKS::E.clone(), /*enum_call*/ROUTES::R7.clone()), (/*enum_call*/BLOCKS::E.clone(), /*enum_call*/ROUTES::R8.clone()), (/*enum_call*/BLOCKS::F.clone(), /*enum_call*/ROUTES::R2.clone()), (/*enum_call*/BLOCKS::F.clone(), /*enum_call*/ROUTES::R3.clone()), (/*enum_call*/BLOCKS::F.clone(), /*enum_call*/ROUTES::R4.clone()), (/*enum_call*/BLOCKS::F.clone(), /*enum_call*/ROUTES::R6.clone()), (/*enum_call*/BLOCKS::F.clone(), /*enum_call*/ROUTES::R7.clone()), (/*enum_call*/BLOCKS::F.clone(), /*enum_call*/ROUTES::R8.clone()), (/*enum_call*/BLOCKS::G.clone(), /*enum_call*/ROUTES::R3.clone()), (/*enum_call*/BLOCKS::G.clone(), /*enum_call*/ROUTES::R4.clone()), (/*enum_call*/BLOCKS::G.clone(), /*enum_call*/ROUTES::R4.clone()), (/*enum_call*/BLOCKS::G.clone(), /*enum_call*/ROUTES::R7.clone()), (/*enum_call*/BLOCKS::G.clone(), /*enum_call*/ROUTES::R8.clone()), (/*enum_call*/BLOCKS::H.clone(), /*enum_call*/ROUTES::R3.clone()), (/*enum_call*/BLOCKS::H.clone(), /*enum_call*/ROUTES::R7.clone()), (/*enum_call*/BLOCKS::I.clone(), /*enum_call*/ROUTES::R4.clone()), (/*enum_call*/BLOCKS::I.clone(), /*enum_call*/ROUTES::R8.clone())];
+ /*body*/self.resrt = bset![ROUTES].clone().clone();
+ self.resbl = bset![BLOCKS].clone().clone();
+ self.rsrtbl = brel![rel_BLOCKS_X_ROUTES].clone().clone();
+ self.OCC = bset![BLOCKS].clone().clone();
+ self.TRK = brel![rel_BLOCKS_X_BLOCKS].clone().clone();
+ self.frm = bset![ROUTES].clone().clone();
+ self.LBT = bset![BLOCKS].clone().clone();
+ /*includesInitialization*/
+ }
+
+ pub fn get_fst(&self) -> rel_ROUTES_X_BLOCKS {
+ return self.fst.clone();
+ }
+
+ pub fn get_lst(&self) -> rel_ROUTES_X_BLOCKS {
+ return self.lst.clone();
+ }
+
+ pub fn get_nxt(&self) -> rel_ROUTES_X_SetBLOCKS_X_BLOCKS {
+ return self.nxt.clone();
+ }
+
+ pub fn get_rtbl(&self) -> rel_BLOCKS_X_ROUTES {
+ return self.rtbl.clone();
+ }
+
+ pub fn get_LBT(&self) -> set_BLOCKS {
+ return self.LBT.clone();
+ }
+
+ pub fn get_TRK(&self) -> rel_BLOCKS_X_BLOCKS {
+ return self.TRK.clone();
+ }
+
+ pub fn get_frm(&self) -> set_ROUTES {
+ return self.frm.clone();
+ }
+
+ pub fn get_OCC(&self) -> set_BLOCKS {
+ return self.OCC.clone();
+ }
+
+ pub fn get_resbl(&self) -> set_BLOCKS {
+ return self.resbl.clone();
+ }
+
+ pub fn get_resrt(&self) -> set_ROUTES {
+ return self.resrt.clone();
+ }
+
+ pub fn get_rsrtbl(&self) -> rel_BLOCKS_X_ROUTES {
+ return self.rsrtbl.clone();
+ }
+
+ pub fn get__BLOCKS(&self) -> set_BLOCKS {
+ return self._BLOCKS.clone();
+ }
+
+ pub fn get__ROUTES(&self) -> set_ROUTES {
+ return self._ROUTES.clone();
+ }
+
+ pub fn route_reservation(&mut self, mut r: ROUTES) -> () {
+ //pre_assert
+ let mut _ld_resrt = self.resrt.clone();
+ let mut _ld_rsrtbl = self.rsrtbl.clone();
+ let mut _ld_resbl = self.resbl.clone();
+ self.resrt = _ld_resrt.union(&bset![ROUTES, r]).clone().clone();
+ self.rsrtbl = _ld_rsrtbl.union(&self.rtbl.rangeRestriction(&bset![ROUTES, r])).clone().clone();
+ self.resbl = _ld_resbl.union(&self.rtbl.inverse().relationImage(&bset![ROUTES, r])).clone().clone();
+
+ }
+
+ pub fn route_freeing(&mut self, mut r: ROUTES) -> () {
+ //pre_assert
+ let mut _ld_frm = self.frm.clone();
+ let mut _ld_resrt = self.resrt.clone();
+ self.resrt = _ld_resrt.difference(&bset![ROUTES, r]).clone().clone();
+ self.frm = _ld_frm.difference(&bset![ROUTES, r]).clone().clone();
+
+ }
+
+ pub fn FRONT_MOVE_1(&mut self, mut r: ROUTES) -> () {
+ //pre_assert
+ let mut _ld_OCC = self.OCC.clone();
+ let mut _ld_LBT = self.LBT.clone();
+ self.OCC = _ld_OCC.union(&bset![BLOCKS, self.fst.functionCall(&r)]).clone().clone();
+ self.LBT = _ld_LBT.union(&bset![BLOCKS, self.fst.functionCall(&r)]).clone().clone();
+
+ }
+
+ pub fn FRONT_MOVE_2(&mut self, mut b: BLOCKS) -> () {
+ //pre_assert
+ self.OCC = self.OCC.union(&bset![BLOCKS, self.TRK.functionCall(&b)]).clone().clone();
+
+ }
+
+ pub fn BACK_MOVE_1(&mut self, mut b: BLOCKS) -> () {
+ //pre_assert
+ let mut _ld_rsrtbl = self.rsrtbl.clone();
+ let mut _ld_resbl = self.resbl.clone();
+ let mut _ld_OCC = self.OCC.clone();
+ let mut _ld_LBT = self.LBT.clone();
+ self.OCC = _ld_OCC.difference(&bset![BLOCKS, b]).clone().clone();
+ self.rsrtbl = _ld_rsrtbl.domainSubstraction(&bset![BLOCKS, b]).clone().clone();
+ self.resbl = _ld_resbl.difference(&bset![BLOCKS, b]).clone().clone();
+ self.LBT = _ld_LBT.difference(&bset![BLOCKS, b]).clone().clone();
+
+ }
+
+ pub fn BACK_MOVE_2(&mut self, mut b: BLOCKS) -> () {
+ //pre_assert
+ let mut _ld_rsrtbl = self.rsrtbl.clone();
+ let mut _ld_resbl = self.resbl.clone();
+ let mut _ld_OCC = self.OCC.clone();
+ let mut _ld_LBT = self.LBT.clone();
+ self.OCC = _ld_OCC.difference(&bset![BLOCKS, b]).clone().clone();
+ self.rsrtbl = _ld_rsrtbl.domainSubstraction(&bset![BLOCKS, b]).clone().clone();
+ self.resbl = _ld_resbl.difference(&bset![BLOCKS, b]).clone().clone();
+ self.LBT = _ld_LBT.difference(&bset![BLOCKS, b]).union(&bset![BLOCKS, self.TRK.functionCall(&b)]).clone().clone();
+
+ }
+
+ pub fn point_positionning(&mut self, mut r: ROUTES) -> () {
+ //pre_assert
+ self.TRK = self.TRK.domainSubstraction(&self.nxt.functionCall(&r).domain()).rangeSubstraction(&self.nxt.functionCall(&r).range()).union(&self.nxt.functionCall(&r)).clone().clone();
+
+ }
+
+ pub fn route_formation(&mut self, mut r: ROUTES) -> () {
+ //pre_assert
+ self.frm = self.frm.union(&bset![ROUTES, r]).clone().clone();
+
+ }
+
+ pub fn _tr_route_reservation(&mut self, is_caching: bool) -> HashSet<ROUTES> {
+ //transition
+ if !is_caching || self._tr_cache_route_reservation.is_none() {
+ let mut _ic_set_0: HashSet<ROUTES> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_r_1 in self._ROUTES.difference(&self.resrt).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if (self.rtbl.inverse().relationImage(&bset![ROUTES, _ic_r_1]).intersect(&self.resbl).equal(&bset![BLOCKS]) && bset![ROUTES].equal(&self.resrt.difference(&self.rsrtbl.range()))) {
+ _ic_set_0.insert(_ic_r_1);
+ }
+
+ }
+ self._tr_cache_route_reservation = Option::Some(_ic_set_0.clone());
+ return _ic_set_0;
+ } else {
+ return self._tr_cache_route_reservation.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_route_freeing(&mut self, is_caching: bool) -> HashSet<ROUTES> {
+ //transition
+ if !is_caching || self._tr_cache_route_freeing.is_none() {
+ let mut _ic_set_1: HashSet<ROUTES> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_r_1 in self.resrt.difference(&self.rsrtbl.range()).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ _ic_set_1.insert(_ic_r_1);
+
+ }
+ self._tr_cache_route_freeing = Option::Some(_ic_set_1.clone());
+ return _ic_set_1;
+ } else {
+ return self._tr_cache_route_freeing.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_FRONT_MOVE_1(&mut self, is_caching: bool) -> HashSet<ROUTES> {
+ //transition
+ if !is_caching || self._tr_cache_FRONT_MOVE_1.is_none() {
+ let mut _ic_set_2: HashSet<ROUTES> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_r_1 in self.frm.clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if ((self.resbl.difference(&self.OCC).elementOf(&self.fst.functionCall(&_ic_r_1)) && _ic_r_1.equal(&self.rsrtbl.functionCall(&self.fst.functionCall(&_ic_r_1)))) && bset![ROUTES].equal(&self.resrt.difference(&self.rsrtbl.range()))) {
+ _ic_set_2.insert(_ic_r_1);
+ }
+
+ }
+ self._tr_cache_FRONT_MOVE_1 = Option::Some(_ic_set_2.clone());
+ return _ic_set_2;
+ } else {
+ return self._tr_cache_FRONT_MOVE_1.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_FRONT_MOVE_2(&mut self, is_caching: bool) -> HashSet<BLOCKS> {
+ //transition
+ if !is_caching || self._tr_cache_FRONT_MOVE_2.is_none() {
+ let mut _ic_set_3: HashSet<BLOCKS> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_b_1 in self.OCC.intersect(&self.TRK.domain()).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if (self.OCC.notElementOf(&self.TRK.functionCall(&_ic_b_1)) && bset![ROUTES].equal(&self.resrt.difference(&self.rsrtbl.range()))) {
+ _ic_set_3.insert(_ic_b_1);
+ }
+
+ }
+ self._tr_cache_FRONT_MOVE_2 = Option::Some(_ic_set_3.clone());
+ return _ic_set_3;
+ } else {
+ return self._tr_cache_FRONT_MOVE_2.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_BACK_MOVE_1(&mut self, is_caching: bool) -> HashSet<BLOCKS> {
+ //transition
+ if !is_caching || self._tr_cache_BACK_MOVE_1.is_none() {
+ let mut _ic_set_4: HashSet<BLOCKS> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_b_1 in self.LBT.difference(&self.TRK.domain()).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if bset![ROUTES].equal(&self.resrt.difference(&self.rsrtbl.range())) {
+ _ic_set_4.insert(_ic_b_1);
+ }
+
+ }
+ self._tr_cache_BACK_MOVE_1 = Option::Some(_ic_set_4.clone());
+ return _ic_set_4;
+ } else {
+ return self._tr_cache_BACK_MOVE_1.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_BACK_MOVE_2(&mut self, is_caching: bool) -> HashSet<BLOCKS> {
+ //transition
+ if !is_caching || self._tr_cache_BACK_MOVE_2.is_none() {
+ let mut _ic_set_5: HashSet<BLOCKS> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_b_1 in self.LBT.intersect(&self.TRK.domain()).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if (self.OCC.elementOf(&self.TRK.functionCall(&_ic_b_1)) && bset![ROUTES].equal(&self.resrt.difference(&self.rsrtbl.range()))) {
+ _ic_set_5.insert(_ic_b_1);
+ }
+
+ }
+ self._tr_cache_BACK_MOVE_2 = Option::Some(_ic_set_5.clone());
+ return _ic_set_5;
+ } else {
+ return self._tr_cache_BACK_MOVE_2.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_point_positionning(&mut self, is_caching: bool) -> HashSet<ROUTES> {
+ //transition
+ if !is_caching || self._tr_cache_point_positionning.is_none() {
+ let mut _ic_set_6: HashSet<ROUTES> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_r_1 in self.resrt.difference(&self.frm).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if bset![ROUTES].equal(&self.resrt.difference(&self.rsrtbl.range())) {
+ _ic_set_6.insert(_ic_r_1);
+ }
+
+ }
+ self._tr_cache_point_positionning = Option::Some(_ic_set_6.clone());
+ return _ic_set_6;
+ } else {
+ return self._tr_cache_point_positionning.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_route_formation(&mut self, is_caching: bool) -> HashSet<ROUTES> {
+ //transition
+ if !is_caching || self._tr_cache_route_formation.is_none() {
+ let mut _ic_set_7: HashSet<ROUTES> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_r_1 in self.resrt.difference(&self.frm).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if (self.nxt.functionCall(&_ic_r_1).domainRestriction(&self.rsrtbl.inverse().relationImage(&bset![ROUTES, _ic_r_1])).equal(&self.TRK.domainRestriction(&self.rsrtbl.inverse().relationImage(&bset![ROUTES, _ic_r_1]))) && bset![ROUTES].equal(&self.resrt.difference(&self.rsrtbl.range()))) {
+ _ic_set_7.insert(_ic_r_1);
+ }
+
+ }
+ self._tr_cache_route_formation = Option::Some(_ic_set_7.clone());
+ return _ic_set_7;
+ } else {
+ return self._tr_cache_route_formation.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _check_inv_1(&self) -> bool {
+ //invariant
+ return self._BLOCKS.check_domain_of(&self.TRK).and(&self._BLOCKS.check_range_of(&self.TRK)).and(&self.TRK.isFunction()).and(&self._BLOCKS.check_partial_of(&self.TRK)).and(&self.TRK.isInjection());
+ }
+
+ pub fn _check_inv_2(&self) -> bool {
+ //invariant
+ //quantified_predicate
+ let mut _ic_boolean_8 = true;
+ //iteration_construct_enumeration
+ for _ic_r_1 in self.resrt.difference(&self.frm).clone().iter() {
+ //iteration_construct_assignment
+ {
+ let mut _ic_a_1 = bset![ROUTES, _ic_r_1];
+ if !self.rtbl.rangeRestriction(&_ic_a_1).equal(&self.rsrtbl.rangeRestriction(&_ic_a_1)) {
+ _ic_boolean_8 = false;
+ break;
+ }
+
+ }
+ }
+
+ return _ic_boolean_8;
+ }
+
+ pub fn _check_inv_3(&self) -> bool {
+ //invariant
+ //quantified_predicate
+ let mut _ic_boolean_10 = true;
+ //iteration_construct_enumeration
+ for _ic_x_1 in self.TRK.domain().clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_y_1 in self.TRK.relationImage(&bset![BLOCKS, _ic_x_1]).clone().iter() {
+ //quantified_predicate
+ let mut _ic_boolean_9 = false;
+ //iteration_construct_enumeration
+ for _ic_r_1 in self._ROUTES.clone().iter() {
+ if self.nxt.functionCall(&_ic_r_1).elementOf(&(_ic_x_1.clone(), _ic_y_1.clone())) {
+ _ic_boolean_9 = true;
+ break;
+ }
+
+ }
+
+ if !_ic_boolean_9 {
+ _ic_boolean_10 = false;
+ break;
+ }
+
+ }
+ }
+
+ return _ic_boolean_10;
+ }
+
+ pub fn _check_inv_4(&self) -> bool {
+ //invariant
+ //quantified_predicate
+ let mut _ic_boolean_11 = true;
+ //iteration_construct_enumeration
+ for _ic_r_1 in self.frm.clone().iter() {
+ //iteration_construct_assignment
+ {
+ let mut _ic_a_1 = self.rsrtbl.inverse().relationImage(&bset![ROUTES, _ic_r_1]);
+ if !self.nxt.functionCall(&_ic_r_1).domainRestriction(&_ic_a_1).equal(&self.TRK.domainRestriction(&_ic_a_1)) {
+ _ic_boolean_11 = false;
+ break;
+ }
+
+ }
+ }
+
+ return _ic_boolean_11;
+ }
+
+ pub fn _check_inv_5(&self) -> bool {
+ //invariant
+ return self.LBT.subset(&self.OCC);
+ }
+
+ pub fn _check_inv_6(&self) -> bool {
+ //invariant
+ //quantified_predicate
+ let mut _ic_boolean_12 = true;
+ //iteration_construct_enumeration
+ for _ic_a_1 in self.rsrtbl.domain().clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_b_1 in self.LBT.clone().iter() {
+ //iteration_construct_assignment
+ {
+ let mut _ic_c_1 = self.rsrtbl.functionCall(&_ic_b_1);
+ //iteration_construct_assignment
+ {
+ let mut _ic_d_1 = self.nxt.functionCall(&_ic_c_1);
+ if !(_ic_d_1.range().elementOf(&_ic_b_1) && _ic_a_1.equal(&_ic_d_1.inverse().functionCall(&_ic_b_1))).implies(|| self.rsrtbl.functionCall(&_ic_a_1).unequal(&_ic_c_1)) {
+ _ic_boolean_12 = false;
+ break;
+ }
+
+ }
+ }
+ }
+ }
+
+ return _ic_boolean_12;
+ }
+
+ pub fn _check_inv_7(&self) -> bool {
+ //invariant
+ return self.resbl.check_domain_of(&self.rsrtbl).and(&self.resrt.check_range_of(&self.rsrtbl)).and(&self.rsrtbl.isFunction()).and(&self.resbl.check_total_of(&self.rsrtbl));
+ }
+
+ pub fn _check_inv_8(&self) -> bool {
+ //invariant
+ return self.rsrtbl.subset(&self.rtbl);
+ }
+
+ pub fn _check_inv_9(&self) -> bool {
+ //invariant
+ return self.OCC.subset(&self.resbl);
+ }
+
+ pub fn _check_inv_10(&self) -> bool {
+ //invariant
+ //quantified_predicate
+ let mut _ic_boolean_13 = true;
+ //iteration_construct_enumeration
+ for _ic_r_1 in self._ROUTES.clone().iter() {
+ //iteration_construct_assignment
+ {
+ let mut _ic_a_1 = self.nxt.functionCall(&_ic_r_1);
+ //iteration_construct_assignment
+ {
+ let mut _ic_b_1 = self.rsrtbl.inverse().relationImage(&bset![ROUTES, _ic_r_1]);
+ //iteration_construct_assignment
+ {
+ let mut _ic_c_1 = _ic_b_1.difference(&self.OCC);
+ if !((_ic_a_1.relationImage(&self.rtbl.inverse().relationImage(&bset![ROUTES, _ic_r_1]).difference(&_ic_b_1)).intersect(&_ic_c_1).equal(&bset![BLOCKS]) && _ic_a_1.relationImage(&_ic_b_1).subset(&_ic_b_1)) && _ic_a_1.relationImage(&_ic_c_1).subset(&_ic_c_1)) {
+ _ic_boolean_13 = false;
+ break;
+ }
+
+ }
+ }
+ }
+ }
+
+ return _ic_boolean_13;
+ }
+
+ pub fn _check_inv_11(&self) -> bool {
+ //invariant
+ return self.frm.subset(&self.resrt);
+ }
+
+ pub fn _check_inv_12(&self) -> bool {
+ //invariant
+ return self.rsrtbl.relationImage(&self.OCC).subset(&self.frm);
+ }
+
+ fn invalidate_caches(&mut self, to_invalidate: Vec<&'static str>) {
+ //calling the given functions without caching will recalculate them and cache them afterwards
+ for trans in to_invalidate {
+ match trans {
+ "_tr_route_reservation" => {self._tr_route_reservation(false);},
+ "_tr_route_freeing" => {self._tr_route_freeing(false);},
+ "_tr_FRONT_MOVE_1" => {self._tr_FRONT_MOVE_1(false);},
+ "_tr_FRONT_MOVE_2" => {self._tr_FRONT_MOVE_2(false);},
+ "_tr_BACK_MOVE_1" => {self._tr_BACK_MOVE_1(false);},
+ "_tr_BACK_MOVE_2" => {self._tr_BACK_MOVE_2(false);},
+ "_tr_point_positionning" => {self._tr_point_positionning(false);},
+ "_tr_route_formation" => {self._tr_route_formation(false);},
+ _ => {},
+ }
+ }
+ }
+
+ //model_check_next_states
+ fn generateNextStates(state: &mut Train1_Lukas_POR_v3,
+ isCaching: bool,
+ transitions: Arc<AtomicU64>) -> HashSet<(Train1_Lukas_POR_v3, &'static str)> {
+ let mut result = HashSet::<(Train1_Lukas_POR_v3, &'static str)>::new();
+ let mut evaluated_transitions: u64 = 0;
+ //model_check_transition
+ let mut _trid_1 = state._tr_route_reservation(isCaching);
+ for param in _trid_1.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.route_reservation(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("route_reservation")); }
+ result.insert((copiedState, "route_reservation"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_2 = state._tr_route_freeing(isCaching);
+ for param in _trid_2.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.route_freeing(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("route_freeing")); }
+ result.insert((copiedState, "route_freeing"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_3 = state._tr_FRONT_MOVE_1(isCaching);
+ for param in _trid_3.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.FRONT_MOVE_1(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("FRONT_MOVE_1")); }
+ result.insert((copiedState, "FRONT_MOVE_1"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_4 = state._tr_FRONT_MOVE_2(isCaching);
+ for param in _trid_4.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.FRONT_MOVE_2(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("FRONT_MOVE_2")); }
+ result.insert((copiedState, "FRONT_MOVE_2"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_5 = state._tr_BACK_MOVE_1(isCaching);
+ for param in _trid_5.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.BACK_MOVE_1(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("BACK_MOVE_1")); }
+ result.insert((copiedState, "BACK_MOVE_1"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_6 = state._tr_BACK_MOVE_2(isCaching);
+ for param in _trid_6.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.BACK_MOVE_2(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("BACK_MOVE_2")); }
+ result.insert((copiedState, "BACK_MOVE_2"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_7 = state._tr_point_positionning(isCaching);
+ for param in _trid_7.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.point_positionning(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("point_positionning")); }
+ result.insert((copiedState, "point_positionning"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_8 = state._tr_route_formation(isCaching);
+ for param in _trid_8.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.route_formation(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("route_formation")); }
+ result.insert((copiedState, "route_formation"));
+ evaluated_transitions += 1;
+ }
+
+
+ transitions.fetch_add(evaluated_transitions, Ordering::AcqRel);
+ return result;
+ }
+
+ //model_check_invariants
+ pub fn checkInvariants(state: &Train1_Lukas_POR_v3, last_op: &'static str, isCaching: bool) -> bool {
+ if isCaching {
+ let dependent_invariants_of_state = Self::get_invariant_dependencies(last_op);
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_1") {
+ if !state._check_inv_1() {
+ println!("_check_inv_1 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_2") {
+ if !state._check_inv_2() {
+ println!("_check_inv_2 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_3") {
+ if !state._check_inv_3() {
+ println!("_check_inv_3 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_4") {
+ if !state._check_inv_4() {
+ println!("_check_inv_4 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_5") {
+ if !state._check_inv_5() {
+ println!("_check_inv_5 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_6") {
+ if !state._check_inv_6() {
+ println!("_check_inv_6 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_7") {
+ if !state._check_inv_7() {
+ println!("_check_inv_7 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_8") {
+ if !state._check_inv_8() {
+ println!("_check_inv_8 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_9") {
+ if !state._check_inv_9() {
+ println!("_check_inv_9 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_10") {
+ if !state._check_inv_10() {
+ println!("_check_inv_10 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_11") {
+ if !state._check_inv_11() {
+ println!("_check_inv_11 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_12") {
+ if !state._check_inv_12() {
+ println!("_check_inv_12 failed!");
+ return false;
+ }
+ }
+ return true;
+ }
+ return !(!state._check_inv_1() || !state._check_inv_2() || !state._check_inv_3() || !state._check_inv_4() || !state._check_inv_5() || !state._check_inv_6() || !state._check_inv_7() || !state._check_inv_8() || !state._check_inv_9() || !state._check_inv_10() || !state._check_inv_11() || !state._check_inv_12());
+ }
+
+ //model_check_print
+ fn print_result(states: usize, transitions: u64, error_detected: bool) {
+ if !error_detected { println!("MODEL CHECKING SUCCESSFUL"); }
+ println!("Number of States: {}", states);
+ println!("Number of Transitions: {}", transitions);
+ }
+
+ //model_check_main
+ fn next(collection_m: Arc<Mutex<LinkedList<(Train1_Lukas_POR_v3, &'static str)>>>, mc_type: MC_TYPE) -> (Train1_Lukas_POR_v3, &'static str) {
+ let mut collection = collection_m.lock().unwrap();
+ return match mc_type {
+ MC_TYPE::BFS => collection.pop_front().unwrap(),
+ MC_TYPE::DFS => collection.pop_back().unwrap(),
+ MC_TYPE::MIXED => if collection.len() % 2 == 0 { collection.pop_front().unwrap() } else { collection.pop_back().unwrap() }
+ };
+ }
+
+ fn get_guard_dependencies(op: &'static str) -> Vec<&str> {
+ return match op {
+ //model_check_init_static
+ "point_positionning" => vec!["_tr_route_formation", "_tr_BACK_MOVE_1", "_tr_FRONT_MOVE_2", "_tr_BACK_MOVE_2"],
+ //model_check_init_static
+ "route_reservation" => vec!["_tr_route_formation", "_tr_FRONT_MOVE_1", "_tr_route_reservation", "_tr_route_freeing", "_tr_BACK_MOVE_1", "_tr_point_positionning", "_tr_FRONT_MOVE_2", "_tr_BACK_MOVE_2"],
+ //model_check_init_static
+ "FRONT_MOVE_1" => vec!["_tr_FRONT_MOVE_1", "_tr_BACK_MOVE_1", "_tr_FRONT_MOVE_2", "_tr_BACK_MOVE_2"],
+ //model_check_init_static
+ "BACK_MOVE_1" => vec!["_tr_route_formation", "_tr_FRONT_MOVE_1", "_tr_route_reservation", "_tr_route_freeing", "_tr_BACK_MOVE_1", "_tr_point_positionning", "_tr_FRONT_MOVE_2", "_tr_BACK_MOVE_2"],
+ //model_check_init_static
+ "FRONT_MOVE_2" => vec!["_tr_FRONT_MOVE_1", "_tr_FRONT_MOVE_2", "_tr_BACK_MOVE_2"],
+ //model_check_init_static
+ "route_formation" => vec!["_tr_route_formation", "_tr_FRONT_MOVE_1", "_tr_point_positionning"],
+ //model_check_init_static
+ "route_freeing" => vec!["_tr_route_formation", "_tr_FRONT_MOVE_1", "_tr_route_reservation", "_tr_route_freeing", "_tr_BACK_MOVE_1", "_tr_point_positionning", "_tr_FRONT_MOVE_2", "_tr_BACK_MOVE_2"],
+ //model_check_init_static
+ "BACK_MOVE_2" => vec!["_tr_route_formation", "_tr_FRONT_MOVE_1", "_tr_route_reservation", "_tr_route_freeing", "_tr_BACK_MOVE_1", "_tr_point_positionning", "_tr_FRONT_MOVE_2", "_tr_BACK_MOVE_2"],
+ _ => vec![],
+ }
+ }
+
+ fn get_invariant_dependencies(op: &'static str) -> Vec<&str> {
+ return match op {
+ //model_check_init_static
+ "point_positionning" => vec!["_check_inv_3", "_check_inv_1", "_check_inv_4"],
+ //model_check_init_static
+ "route_reservation" => vec!["_check_inv_2", "_check_inv_6", "_check_inv_10", "_check_inv_7", "_check_inv_4", "_check_inv_8", "_check_inv_12", "_check_inv_9", "_check_inv_11"],
+ //model_check_init_static
+ "FRONT_MOVE_1" => vec!["_check_inv_6", "_check_inv_10", "_check_inv_5", "_check_inv_12", "_check_inv_9"],
+ //model_check_init_static
+ "BACK_MOVE_1" => vec!["_check_inv_2", "_check_inv_6", "_check_inv_10", "_check_inv_7", "_check_inv_4", "_check_inv_5", "_check_inv_8", "_check_inv_12", "_check_inv_9"],
+ //model_check_init_static
+ "FRONT_MOVE_2" => vec!["_check_inv_10", "_check_inv_5", "_check_inv_12", "_check_inv_9"],
+ //model_check_init_static
+ "route_formation" => vec!["_check_inv_2", "_check_inv_4", "_check_inv_12", "_check_inv_11"],
+ //model_check_init_static
+ "route_freeing" => vec!["_check_inv_2", "_check_inv_7", "_check_inv_4", "_check_inv_12", "_check_inv_11"],
+ //model_check_init_static
+ "BACK_MOVE_2" => vec!["_check_inv_2", "_check_inv_6", "_check_inv_10", "_check_inv_7", "_check_inv_4", "_check_inv_5", "_check_inv_8", "_check_inv_12", "_check_inv_9"],
+ _ => vec![],
+ }
+ }
+
+ fn model_check_single_threaded(mc_type: MC_TYPE, is_caching: bool, no_dead: bool, no_inv: bool) {
+ let mut machine = Train1_Lukas_POR_v3::new();
+
+ let mut all_states = HashSet::<Train1_Lukas_POR_v3>::new();
+ all_states.insert(machine.clone());
+
+ let states_to_process_mutex = Arc::new(Mutex::new(LinkedList::<(Train1_Lukas_POR_v3, &'static str)>::new()));
+ states_to_process_mutex.lock().unwrap().push_back((machine.clone(), ""));
+
+ let num_transitions = Arc::new(AtomicU64::new(0));
+
+ let mut stop_threads = false;
+
+ while !stop_threads && !states_to_process_mutex.lock().unwrap().is_empty() {
+ let (mut state, last_op) = Self::next(Arc::clone(&states_to_process_mutex), mc_type);
+
+ let next_states = Self::generateNextStates(&mut state, is_caching, Arc::clone(&num_transitions));
+
+ if !no_inv && !Self::checkInvariants(&state, last_op, is_caching) {
+ println!("INVARIANT VIOLATED");
+ stop_threads = true;
+ }
+ if !no_dead && next_states.is_empty() {
+ print!("DEADLOCK DETECTED");
+ stop_threads = true;
+ }
+
+ next_states.into_iter()
+ .filter(|(next_state, _)| all_states.insert((*next_state).clone()))
+ .for_each(|(next_state, last_op)| states_to_process_mutex.lock().unwrap().push_back((next_state, last_op)));
+
+ if all_states.len() % 50000 == 0 {
+ println!("VISITED STATES: {}", all_states.len());
+ println!("EVALUATED TRANSITIONS: {}", num_transitions.load(Ordering::Acquire));
+ println!("-------------------");
+ }
+ }
+ Self::print_result(all_states.len(), num_transitions.load(Ordering::Acquire), stop_threads);
+ }
+
+ fn modelCheckMultiThreaded(mc_type: MC_TYPE, threads: usize, is_caching: bool, no_dead: bool, no_inv: bool) {
+ let threadPool = ThreadPool::new(threads);
+
+ let machine = Train1_Lukas_POR_v3::new();
+
+ let all_states = Arc::new(DashSet::<Train1_Lukas_POR_v3>::new());
+ all_states.insert(machine.clone());
+
+ let states_to_process_mutex = Arc::new(Mutex::new(LinkedList::<(Train1_Lukas_POR_v3, &'static str)>::new()));
+ states_to_process_mutex.lock().unwrap().push_back((machine, ""));
+
+ let num_transitions = Arc::new(AtomicU64::new(0));
+
+ let mut stop_threads = false;
+ let mut spawned_tasks: u64 = 0;
+ let mut finished_tasks: u64 = 0;
+
+ let (tx, rx) = channel();
+ //println!("Thread {:?} starting threads", thread::current().id());
+ while !stop_threads && !states_to_process_mutex.lock().unwrap().is_empty() {
+ let (mut state, last_op) = Self::next(Arc::clone(&states_to_process_mutex), mc_type);
+
+ let states_to_process = Arc::clone(&states_to_process_mutex);
+ let transitions = Arc::clone(&num_transitions);
+ let states = Arc::clone(&all_states);
+ let tx = tx.clone();
+ //println!("Thread {:?} spawning a thread", thread::current().id());
+ threadPool.execute(move|| {
+ let next_states = Self::generateNextStates(&mut state, is_caching, transitions);
+ if !no_dead && next_states.is_empty() { let _ = tx.send(Err("DEADLOCK DETECTED")); }
+
+ //println!("Thread {:?} executing", thread::current().id());
+ next_states.into_iter()
+ .filter(|(next_state, _)| states.insert((*next_state).clone()))
+ .for_each(|(next_state, last_op)| states_to_process.lock().unwrap().push_back((next_state, last_op)));
+
+ if !no_inv && !Self::checkInvariants(&state, last_op, is_caching) {
+ let _ = tx.send(Err("INVARIANT VIOLATED"));
+ }
+ //println!("Thread {:?} done", thread::current().id());
+ let _ = tx.send(Ok(1));
+ });
+
+ spawned_tasks += 1;
+ if spawned_tasks % 50000 == 0 {
+ println!("VISITED STATES: {}", all_states.len());
+ println!("EVALUATED TRANSITIONS: {}", num_transitions.load(Ordering::Acquire));
+ println!("-------------------");
+ }
+
+ while states_to_process_mutex.lock().unwrap().is_empty() && spawned_tasks - finished_tasks > 0 {
+ //println!("Thread {:?} (main) waiting for a thread to finish", thread::current().id());
+ match rx.try_recv() {
+ Ok(val) => match val {
+ Ok(_) => finished_tasks += 1,
+ Err(msg) => { println!("{}", msg); stop_threads = true; },
+ },
+ Err(_) => (),
+ }
+ if threadPool.panic_count() > 0 { stop_threads = true; }
+ }
+ }
+
+ Self::print_result(all_states.len(), num_transitions.load(Ordering::Acquire), stop_threads);
+ }
+
+}
+
+
+fn main() {
+ let args: Vec<String> = env::args().collect();
+ if args.len() < 4 { panic!("Number of arguments errorneous"); }
+
+ let threads = args.get(2).unwrap().parse::<usize>().unwrap();
+ if threads <= 0 { panic!("Input for number of threads is wrong."); }
+
+ let is_caching = args.get(3).unwrap().parse::<bool>().unwrap();
+ let mc_type = match args.get(1).unwrap().as_str() {
+ "mixed" => MC_TYPE::MIXED,
+ "bf" => MC_TYPE::BFS,
+ "df" => MC_TYPE::DFS,
+ _ => panic!("Input for strategy is wrong.")
+ };
+
+ let mut no_dead = false;
+ let mut no_inv = false;
+
+ if args.len() > 4 {
+ for arg in args.iter().skip(4) {
+ match arg.as_str() {
+ "-nodead" => no_dead = true,
+ "-noinv" => no_inv = true,
+ _ => {}
+ }
+ }
+ }
+
+ if threads == 1 {
+ Train1_Lukas_POR_v3::model_check_single_threaded(mc_type, is_caching, no_dead, no_inv);
+ } else {
+ Train1_Lukas_POR_v3::modelCheckMultiThreaded(mc_type, threads, is_caching, no_dead, no_inv);
+ }
+}
diff --git a/benchmarks/model_checking/Rust_embedded/Train_1_beebook_deterministic_MC_POR_v2.rs b/benchmarks/model_checking/Rust_embedded/Train_1_beebook_deterministic_MC_POR_v2.rs
new file mode 100644
index 000000000..2c0f20e98
--- /dev/null
+++ b/benchmarks/model_checking/Rust_embedded/Train_1_beebook_deterministic_MC_POR_v2.rs
@@ -0,0 +1,1671 @@
+#![ allow( dead_code, unused, non_snake_case, non_camel_case_types, unused_assignments ) ]
+//#![no_std] //std is enabled for the generated machine by default, since without it there is no println which makes unit-testing very difficult
+use btypes::{bset, brel};
+use btypes::bset::BSet;
+use btypes::bset::SetItem;
+use btypes::bset::PowSetItem;
+use btypes::bset::PowAble;
+use btypes::bset::NestedSet;
+use btypes::brelation::BRelation;
+use btypes::brelation::RelLeftItem;
+use btypes::brelation::RelPowAble;
+use btypes::bboolean::BBoolean;
+use btypes::bboolean::BBool;
+use btypes::bboolean::BOOL;
+use btypes::binteger::BInteger;
+use btypes::binteger::BInt;
+use btypes::binteger::set_BInteger;
+use btypes::btuple::BTuple;
+
+use std::env;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, mpsc, Mutex};
+use std::collections::{HashSet, LinkedList};
+use dashmap::DashSet;
+use threadpool::ThreadPool;
+use std::sync::mpsc::channel;
+use derivative::Derivative;
+use std::time::{Duration};
+
+
+
+#[derive(Clone, Copy)]
+pub enum MC_TYPE { BFS, DFS, MIXED }
+
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum BLOCKS {
+ #[default]
+ A = 0,
+ B = 1,
+ C = 2,
+ D = 3,
+ E = 4,
+ F = 5,
+ G = 6,
+ H = 7,
+ I = 8,
+ J = 9,
+ K = 10,
+ L = 11,
+ M = 12,
+ N = 13
+}
+
+impl BLOCKS {
+ pub fn equal(&self, other: &BLOCKS) -> bool { *self == *other }
+ pub fn unequal(&self, other: &BLOCKS) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::A,
+ 1 => Self::B,
+ 2 => Self::C,
+ 3 => Self::D,
+ 4 => Self::E,
+ 5 => Self::F,
+ 6 => Self::G,
+ 7 => Self::H,
+ 8 => Self::I,
+ 9 => Self::J,
+ 10 => Self::K,
+ 11 => Self::L,
+ 12 => Self::M,
+ 13 => Self::N,
+ _ => panic!("BLOCKS index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<14> for BLOCKS {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_BLOCKS = BSet<BLOCKS, 14>;
+//set_enum_declaration done
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum ROUTES {
+ #[default]
+ R1 = 0,
+ R2 = 1,
+ R3 = 2,
+ R4 = 3,
+ R5 = 4,
+ R6 = 5,
+ R7 = 6,
+ R8 = 7,
+ R9 = 8,
+ R10 = 9
+}
+
+impl ROUTES {
+ pub fn equal(&self, other: &ROUTES) -> bool { *self == *other }
+ pub fn unequal(&self, other: &ROUTES) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::R1,
+ 1 => Self::R2,
+ 2 => Self::R3,
+ 3 => Self::R4,
+ 4 => Self::R5,
+ 5 => Self::R6,
+ 6 => Self::R7,
+ 7 => Self::R8,
+ 8 => Self::R9,
+ 9 => Self::R10,
+ _ => panic!("ROUTES index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<10> for ROUTES {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_ROUTES = BSet<ROUTES, 10>;
+//set_enum_declaration done
+
+//relation_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum BLOCKS_X_BLOCKS {
+ #[default]
+ A_A = 0,
+ A_B = 1,
+ A_C = 2,
+ A_D = 3,
+ A_E = 4,
+ A_F = 5,
+ A_G = 6,
+ A_H = 7,
+ A_I = 8,
+ A_J = 9,
+ A_K = 10,
+ A_L = 11,
+ A_M = 12,
+ A_N = 13,
+ B_A = 14,
+ B_B = 15,
+ B_C = 16,
+ B_D = 17,
+ B_E = 18,
+ B_F = 19,
+ B_G = 20,
+ B_H = 21,
+ B_I = 22,
+ B_J = 23,
+ B_K = 24,
+ B_L = 25,
+ B_M = 26,
+ B_N = 27,
+ C_A = 28,
+ C_B = 29,
+ C_C = 30,
+ C_D = 31,
+ C_E = 32,
+ C_F = 33,
+ C_G = 34,
+ C_H = 35,
+ C_I = 36,
+ C_J = 37,
+ C_K = 38,
+ C_L = 39,
+ C_M = 40,
+ C_N = 41,
+ D_A = 42,
+ D_B = 43,
+ D_C = 44,
+ D_D = 45,
+ D_E = 46,
+ D_F = 47,
+ D_G = 48,
+ D_H = 49,
+ D_I = 50,
+ D_J = 51,
+ D_K = 52,
+ D_L = 53,
+ D_M = 54,
+ D_N = 55,
+ E_A = 56,
+ E_B = 57,
+ E_C = 58,
+ E_D = 59,
+ E_E = 60,
+ E_F = 61,
+ E_G = 62,
+ E_H = 63,
+ E_I = 64,
+ E_J = 65,
+ E_K = 66,
+ E_L = 67,
+ E_M = 68,
+ E_N = 69,
+ F_A = 70,
+ F_B = 71,
+ F_C = 72,
+ F_D = 73,
+ F_E = 74,
+ F_F = 75,
+ F_G = 76,
+ F_H = 77,
+ F_I = 78,
+ F_J = 79,
+ F_K = 80,
+ F_L = 81,
+ F_M = 82,
+ F_N = 83,
+ G_A = 84,
+ G_B = 85,
+ G_C = 86,
+ G_D = 87,
+ G_E = 88,
+ G_F = 89,
+ G_G = 90,
+ G_H = 91,
+ G_I = 92,
+ G_J = 93,
+ G_K = 94,
+ G_L = 95,
+ G_M = 96,
+ G_N = 97,
+ H_A = 98,
+ H_B = 99,
+ H_C = 100,
+ H_D = 101,
+ H_E = 102,
+ H_F = 103,
+ H_G = 104,
+ H_H = 105,
+ H_I = 106,
+ H_J = 107,
+ H_K = 108,
+ H_L = 109,
+ H_M = 110,
+ H_N = 111,
+ I_A = 112,
+ I_B = 113,
+ I_C = 114,
+ I_D = 115,
+ I_E = 116,
+ I_F = 117,
+ I_G = 118,
+ I_H = 119,
+ I_I = 120,
+ I_J = 121,
+ I_K = 122,
+ I_L = 123,
+ I_M = 124,
+ I_N = 125,
+ J_A = 126,
+ J_B = 127,
+ J_C = 128,
+ J_D = 129,
+ J_E = 130,
+ J_F = 131,
+ J_G = 132,
+ J_H = 133,
+ J_I = 134,
+ J_J = 135,
+ J_K = 136,
+ J_L = 137,
+ J_M = 138,
+ J_N = 139,
+ K_A = 140,
+ K_B = 141,
+ K_C = 142,
+ K_D = 143,
+ K_E = 144,
+ K_F = 145,
+ K_G = 146,
+ K_H = 147,
+ K_I = 148,
+ K_J = 149,
+ K_K = 150,
+ K_L = 151,
+ K_M = 152,
+ K_N = 153,
+ L_A = 154,
+ L_B = 155,
+ L_C = 156,
+ L_D = 157,
+ L_E = 158,
+ L_F = 159,
+ L_G = 160,
+ L_H = 161,
+ L_I = 162,
+ L_J = 163,
+ L_K = 164,
+ L_L = 165,
+ L_M = 166,
+ L_N = 167,
+ M_A = 168,
+ M_B = 169,
+ M_C = 170,
+ M_D = 171,
+ M_E = 172,
+ M_F = 173,
+ M_G = 174,
+ M_H = 175,
+ M_I = 176,
+ M_J = 177,
+ M_K = 178,
+ M_L = 179,
+ M_M = 180,
+ M_N = 181,
+ N_A = 182,
+ N_B = 183,
+ N_C = 184,
+ N_D = 185,
+ N_E = 186,
+ N_F = 187,
+ N_G = 188,
+ N_H = 189,
+ N_I = 190,
+ N_J = 191,
+ N_K = 192,
+ N_L = 193,
+ N_M = 194,
+ N_N = 195
+}
+type rel_BLOCKS_X_BLOCKS = BRelation<BLOCKS, { BLOCKS::VARIANTS }, BLOCKS, { BLOCKS::VARIANTS }, 196>;
+//relation_declaration done
+
+
+
+//relation_declaration
+type rel_ROUTES_X_SetBLOCKS_X_BLOCKS = BRelation<ROUTES, { ROUTES::VARIANTS }, rel_BLOCKS_X_BLOCKS, { rel_BLOCKS_X_BLOCKS::VARIANTS }, 0>;
+//relation_declaration done
+
+
+
+//enum_set_declaration start
+#[derive(Default, Debug, Clone, Copy)]
+// each enum value corresponds to one BSet
+pub enum SetBLOCKS_X_BLOCKS {
+ #[default]
+ SET_SET_A_B__B_C__L_A_TES_TES = 0,
+ SET_SET_A_B__B_D__D_E__E_F__F_G__L_A_TES_TES = 1,
+ SET_SET_A_B__B_D__D_K__J_N__K_J__L_A_TES_TES = 2,
+ SET_SET_F_G__H_I__I_K__K_F__M_H_TES_TES = 3,
+ SET_SET_H_I__I_J__J_N__M_H_TES_TES = 4,
+ SET_SET_A_L__B_A__C_B_TES_TES = 5,
+ SET_SET_A_L__B_A__D_B__E_D__F_E__G_F_TES_TES = 6,
+ SET_SET_A_L__B_A__D_B__J_K__K_D__N_J_TES_TES = 7,
+ SET_SET_F_K__G_F__H_M__I_H__K_I_TES_TES = 8,
+ SET_SET_H_M__I_H__J_I__N_J_TES_TES = 9
+}
+type set_SetBLOCKS_X_BLOCKS = BSet<rel_BLOCKS_X_BLOCKS, 10>;
+
+impl PowSetItem<10, 196> for BLOCKS_X_BLOCKS {
+ type SetRepr = SetBLOCKS_X_BLOCKS;
+ fn arr_to_idx(set: [bool; 196]) -> usize {
+ match set {
+ [false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false] => 0,
+ [false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false] => 1,
+ [false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, true, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false] => 2,
+ [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false] => 3,
+ [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false] => 4,
+ [false, false, false, false, false, false, false, false, false, false, false, true, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false] => 5,
+ [false, false, false, false, false, false, false, false, false, false, false, true, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false] => 6,
+ [false, false, false, false, false, false, false, false, false, false, false, true, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false] => 7,
+ [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false] => 8,
+ [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false] => 9,
+ _ => panic!("Attempting to convert non-existing set to index!") // only happens if this is a const-set and code-generation missed a necessary value
+ }
+ }
+ fn idx_to_arr(idx: usize) -> [bool; 196] {
+ match idx {
+ 0 => [false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false],
+ 1 => [false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false],
+ 2 => [false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, true, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false],
+ 3 => [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false],
+ 4 => [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false],
+ 5 => [false, false, false, false, false, false, false, false, false, false, false, true, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false],
+ 6 => [false, false, false, false, false, false, false, false, false, false, false, true, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false],
+ 7 => [false, false, false, false, false, false, false, false, false, false, false, true, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false],
+ 8 => [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false],
+ 9 => [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false],
+ _ => panic!("SetBLOCKS_X_BLOCKS index out of range! {:?}", idx)
+ }
+ }
+}
+impl RelLeftItem<{BLOCKS::VARIANTS}, BLOCKS, { BLOCKS::VARIANTS}, 10, 196> for BLOCKS {
+ type RelEnum = BLOCKS_X_BLOCKS;
+}
+impl SetBLOCKS_X_BLOCKS {
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::SET_SET_A_B__B_C__L_A_TES_TES,
+ 1 => Self::SET_SET_A_B__B_D__D_E__E_F__F_G__L_A_TES_TES,
+ 2 => Self::SET_SET_A_B__B_D__D_K__J_N__K_J__L_A_TES_TES,
+ 3 => Self::SET_SET_F_G__H_I__I_K__K_F__M_H_TES_TES,
+ 4 => Self::SET_SET_H_I__I_J__J_N__M_H_TES_TES,
+ 5 => Self::SET_SET_A_L__B_A__C_B_TES_TES,
+ 6 => Self::SET_SET_A_L__B_A__D_B__E_D__F_E__G_F_TES_TES,
+ 7 => Self::SET_SET_A_L__B_A__D_B__J_K__K_D__N_J_TES_TES,
+ 8 => Self::SET_SET_F_K__G_F__H_M__I_H__K_I_TES_TES,
+ 9 => Self::SET_SET_H_M__I_H__J_I__N_J_TES_TES,
+ _ => panic!("SetBLOCKS_X_BLOCKS index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<10> for SetBLOCKS_X_BLOCKS {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+//enum_set_declaration done
+
+//relation_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum ROUTES_X_BLOCKS {
+ #[default]
+ R1_A = 0,
+ R1_B = 1,
+ R1_C = 2,
+ R1_D = 3,
+ R1_E = 4,
+ R1_F = 5,
+ R1_G = 6,
+ R1_H = 7,
+ R1_I = 8,
+ R1_J = 9,
+ R1_K = 10,
+ R1_L = 11,
+ R1_M = 12,
+ R1_N = 13,
+ R2_A = 14,
+ R2_B = 15,
+ R2_C = 16,
+ R2_D = 17,
+ R2_E = 18,
+ R2_F = 19,
+ R2_G = 20,
+ R2_H = 21,
+ R2_I = 22,
+ R2_J = 23,
+ R2_K = 24,
+ R2_L = 25,
+ R2_M = 26,
+ R2_N = 27,
+ R3_A = 28,
+ R3_B = 29,
+ R3_C = 30,
+ R3_D = 31,
+ R3_E = 32,
+ R3_F = 33,
+ R3_G = 34,
+ R3_H = 35,
+ R3_I = 36,
+ R3_J = 37,
+ R3_K = 38,
+ R3_L = 39,
+ R3_M = 40,
+ R3_N = 41,
+ R4_A = 42,
+ R4_B = 43,
+ R4_C = 44,
+ R4_D = 45,
+ R4_E = 46,
+ R4_F = 47,
+ R4_G = 48,
+ R4_H = 49,
+ R4_I = 50,
+ R4_J = 51,
+ R4_K = 52,
+ R4_L = 53,
+ R4_M = 54,
+ R4_N = 55,
+ R5_A = 56,
+ R5_B = 57,
+ R5_C = 58,
+ R5_D = 59,
+ R5_E = 60,
+ R5_F = 61,
+ R5_G = 62,
+ R5_H = 63,
+ R5_I = 64,
+ R5_J = 65,
+ R5_K = 66,
+ R5_L = 67,
+ R5_M = 68,
+ R5_N = 69,
+ R6_A = 70,
+ R6_B = 71,
+ R6_C = 72,
+ R6_D = 73,
+ R6_E = 74,
+ R6_F = 75,
+ R6_G = 76,
+ R6_H = 77,
+ R6_I = 78,
+ R6_J = 79,
+ R6_K = 80,
+ R6_L = 81,
+ R6_M = 82,
+ R6_N = 83,
+ R7_A = 84,
+ R7_B = 85,
+ R7_C = 86,
+ R7_D = 87,
+ R7_E = 88,
+ R7_F = 89,
+ R7_G = 90,
+ R7_H = 91,
+ R7_I = 92,
+ R7_J = 93,
+ R7_K = 94,
+ R7_L = 95,
+ R7_M = 96,
+ R7_N = 97,
+ R8_A = 98,
+ R8_B = 99,
+ R8_C = 100,
+ R8_D = 101,
+ R8_E = 102,
+ R8_F = 103,
+ R8_G = 104,
+ R8_H = 105,
+ R8_I = 106,
+ R8_J = 107,
+ R8_K = 108,
+ R8_L = 109,
+ R8_M = 110,
+ R8_N = 111,
+ R9_A = 112,
+ R9_B = 113,
+ R9_C = 114,
+ R9_D = 115,
+ R9_E = 116,
+ R9_F = 117,
+ R9_G = 118,
+ R9_H = 119,
+ R9_I = 120,
+ R9_J = 121,
+ R9_K = 122,
+ R9_L = 123,
+ R9_M = 124,
+ R9_N = 125,
+ R10_A = 126,
+ R10_B = 127,
+ R10_C = 128,
+ R10_D = 129,
+ R10_E = 130,
+ R10_F = 131,
+ R10_G = 132,
+ R10_H = 133,
+ R10_I = 134,
+ R10_J = 135,
+ R10_K = 136,
+ R10_L = 137,
+ R10_M = 138,
+ R10_N = 139
+}
+type rel_ROUTES_X_BLOCKS = BRelation<ROUTES, { ROUTES::VARIANTS }, BLOCKS, { BLOCKS::VARIANTS }, 140>;
+//relation_declaration done
+
+//relation_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum BLOCKS_X_ROUTES {
+ #[default]
+ A_R1 = 0,
+ A_R2 = 1,
+ A_R3 = 2,
+ A_R4 = 3,
+ A_R5 = 4,
+ A_R6 = 5,
+ A_R7 = 6,
+ A_R8 = 7,
+ A_R9 = 8,
+ A_R10 = 9,
+ B_R1 = 10,
+ B_R2 = 11,
+ B_R3 = 12,
+ B_R4 = 13,
+ B_R5 = 14,
+ B_R6 = 15,
+ B_R7 = 16,
+ B_R8 = 17,
+ B_R9 = 18,
+ B_R10 = 19,
+ C_R1 = 20,
+ C_R2 = 21,
+ C_R3 = 22,
+ C_R4 = 23,
+ C_R5 = 24,
+ C_R6 = 25,
+ C_R7 = 26,
+ C_R8 = 27,
+ C_R9 = 28,
+ C_R10 = 29,
+ D_R1 = 30,
+ D_R2 = 31,
+ D_R3 = 32,
+ D_R4 = 33,
+ D_R5 = 34,
+ D_R6 = 35,
+ D_R7 = 36,
+ D_R8 = 37,
+ D_R9 = 38,
+ D_R10 = 39,
+ E_R1 = 40,
+ E_R2 = 41,
+ E_R3 = 42,
+ E_R4 = 43,
+ E_R5 = 44,
+ E_R6 = 45,
+ E_R7 = 46,
+ E_R8 = 47,
+ E_R9 = 48,
+ E_R10 = 49,
+ F_R1 = 50,
+ F_R2 = 51,
+ F_R3 = 52,
+ F_R4 = 53,
+ F_R5 = 54,
+ F_R6 = 55,
+ F_R7 = 56,
+ F_R8 = 57,
+ F_R9 = 58,
+ F_R10 = 59,
+ G_R1 = 60,
+ G_R2 = 61,
+ G_R3 = 62,
+ G_R4 = 63,
+ G_R5 = 64,
+ G_R6 = 65,
+ G_R7 = 66,
+ G_R8 = 67,
+ G_R9 = 68,
+ G_R10 = 69,
+ H_R1 = 70,
+ H_R2 = 71,
+ H_R3 = 72,
+ H_R4 = 73,
+ H_R5 = 74,
+ H_R6 = 75,
+ H_R7 = 76,
+ H_R8 = 77,
+ H_R9 = 78,
+ H_R10 = 79,
+ I_R1 = 80,
+ I_R2 = 81,
+ I_R3 = 82,
+ I_R4 = 83,
+ I_R5 = 84,
+ I_R6 = 85,
+ I_R7 = 86,
+ I_R8 = 87,
+ I_R9 = 88,
+ I_R10 = 89,
+ J_R1 = 90,
+ J_R2 = 91,
+ J_R3 = 92,
+ J_R4 = 93,
+ J_R5 = 94,
+ J_R6 = 95,
+ J_R7 = 96,
+ J_R8 = 97,
+ J_R9 = 98,
+ J_R10 = 99,
+ K_R1 = 100,
+ K_R2 = 101,
+ K_R3 = 102,
+ K_R4 = 103,
+ K_R5 = 104,
+ K_R6 = 105,
+ K_R7 = 106,
+ K_R8 = 107,
+ K_R9 = 108,
+ K_R10 = 109,
+ L_R1 = 110,
+ L_R2 = 111,
+ L_R3 = 112,
+ L_R4 = 113,
+ L_R5 = 114,
+ L_R6 = 115,
+ L_R7 = 116,
+ L_R8 = 117,
+ L_R9 = 118,
+ L_R10 = 119,
+ M_R1 = 120,
+ M_R2 = 121,
+ M_R3 = 122,
+ M_R4 = 123,
+ M_R5 = 124,
+ M_R6 = 125,
+ M_R7 = 126,
+ M_R8 = 127,
+ M_R9 = 128,
+ M_R10 = 129,
+ N_R1 = 130,
+ N_R2 = 131,
+ N_R3 = 132,
+ N_R4 = 133,
+ N_R5 = 134,
+ N_R6 = 135,
+ N_R7 = 136,
+ N_R8 = 137,
+ N_R9 = 138,
+ N_R10 = 139
+}
+type rel_BLOCKS_X_ROUTES = BRelation<BLOCKS, { BLOCKS::VARIANTS }, ROUTES, { ROUTES::VARIANTS }, 140>;
+//relation_declaration done
+
+#[derive(Derivative)]
+#[derivative(Clone, Default, Debug, Hash, PartialEq, Eq)]
+pub struct Train_1_beebook_deterministic_MC_POR_v2 {
+ /*declarations*/LBT: set_BLOCKS,
+ TRK: rel_BLOCKS_X_BLOCKS,
+ frm: set_ROUTES,
+ OCC: set_BLOCKS,
+ resbl: set_BLOCKS,
+ resrt: set_ROUTES,
+ rsrtbl: rel_BLOCKS_X_ROUTES,
+ /*constant_declarations*/fst: rel_ROUTES_X_BLOCKS,
+ lst: rel_ROUTES_X_BLOCKS,
+ nxt: rel_ROUTES_X_SetBLOCKS_X_BLOCKS,
+ rtbl: rel_BLOCKS_X_ROUTES,
+ /*sets*//*set_declaration*/_BLOCKS: set_BLOCKS,
+ /*set_declaration*/_ROUTES: set_ROUTES,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_route_reservation: Option<HashSet<ROUTES>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_route_freeing: Option<HashSet<ROUTES>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_FRONT_MOVE_1: Option<HashSet<ROUTES>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_FRONT_MOVE_2: Option<HashSet<BLOCKS>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_BACK_MOVE_1: Option<HashSet<BLOCKS>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_BACK_MOVE_2: Option<HashSet<BLOCKS>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_point_positionning: Option<HashSet<ROUTES>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_route_formation: Option<HashSet<ROUTES>>,}
+
+
+impl Train_1_beebook_deterministic_MC_POR_v2 {
+
+ pub fn new() -> Train_1_beebook_deterministic_MC_POR_v2 {
+ //values: ''
+ let mut m: Train_1_beebook_deterministic_MC_POR_v2 = Default::default();
+ m.init();
+ return m;
+ }
+ fn init(&mut self) {
+ /*set_initializations*///set_initialization
+ self._BLOCKS = bset![BLOCKS, /*enum_call*/BLOCKS::A, /*enum_call*/BLOCKS::B, /*enum_call*/BLOCKS::C, /*enum_call*/BLOCKS::D, /*enum_call*/BLOCKS::E, /*enum_call*/BLOCKS::F, /*enum_call*/BLOCKS::G, /*enum_call*/BLOCKS::H, /*enum_call*/BLOCKS::I, /*enum_call*/BLOCKS::J, /*enum_call*/BLOCKS::K, /*enum_call*/BLOCKS::L, /*enum_call*/BLOCKS::M, /*enum_call*/BLOCKS::N];
+ //set_initialization
+ self._ROUTES = bset![ROUTES, /*enum_call*/ROUTES::R1, /*enum_call*/ROUTES::R2, /*enum_call*/ROUTES::R3, /*enum_call*/ROUTES::R4, /*enum_call*/ROUTES::R5, /*enum_call*/ROUTES::R6, /*enum_call*/ROUTES::R7, /*enum_call*/ROUTES::R8, /*enum_call*/ROUTES::R9, /*enum_call*/ROUTES::R10];
+ /*properties*///constant_initialization
+ self.nxt = brel![rel_ROUTES_X_SetBLOCKS_X_BLOCKS, (/*enum_call*/ROUTES::R1.clone(), brel![rel_BLOCKS_X_BLOCKS, (/*enum_call*/BLOCKS::L.clone(), /*enum_call*/BLOCKS::A.clone()), (/*enum_call*/BLOCKS::A.clone(), /*enum_call*/BLOCKS::B.clone()), (/*enum_call*/BLOCKS::B.clone(), /*enum_call*/BLOCKS::C.clone())].clone()), (/*enum_call*/ROUTES::R2.clone(), brel![rel_BLOCKS_X_BLOCKS, (/*enum_call*/BLOCKS::L.clone(), /*enum_call*/BLOCKS::A.clone()), (/*enum_call*/BLOCKS::A.clone(), /*enum_call*/BLOCKS::B.clone()), (/*enum_call*/BLOCKS::B.clone(), /*enum_call*/BLOCKS::D.clone()), (/*enum_call*/BLOCKS::D.clone(), /*enum_call*/BLOCKS::E.clone()), (/*enum_call*/BLOCKS::E.clone(), /*enum_call*/BLOCKS::F.clone()), (/*enum_call*/BLOCKS::F.clone(), /*enum_call*/BLOCKS::G.clone())].clone()), (/*enum_call*/ROUTES::R3.clone(), brel![rel_BLOCKS_X_BLOCKS, (/*enum_call*/BLOCKS::L.clone(), /*enum_call*/BLOCKS::A.clone()), (/*enum_call*/BLOCKS::A.clone(), /*enum_call*/BLOCKS::B.clone()), (/*enum_call*/BLOCKS::B.clone(), /*enum_call*/BLOCKS::D.clone()), (/*enum_call*/BLOCKS::D.clone(), /*enum_call*/BLOCKS::K.clone()), (/*enum_call*/BLOCKS::K.clone(), /*enum_call*/BLOCKS::J.clone()), (/*enum_call*/BLOCKS::J.clone(), /*enum_call*/BLOCKS::N.clone())].clone()), (/*enum_call*/ROUTES::R4.clone(), brel![rel_BLOCKS_X_BLOCKS, (/*enum_call*/BLOCKS::M.clone(), /*enum_call*/BLOCKS::H.clone()), (/*enum_call*/BLOCKS::H.clone(), /*enum_call*/BLOCKS::I.clone()), (/*enum_call*/BLOCKS::I.clone(), /*enum_call*/BLOCKS::K.clone()), (/*enum_call*/BLOCKS::K.clone(), /*enum_call*/BLOCKS::F.clone()), (/*enum_call*/BLOCKS::F.clone(), /*enum_call*/BLOCKS::G.clone())].clone()), (/*enum_call*/ROUTES::R5.clone(), brel![rel_BLOCKS_X_BLOCKS, (/*enum_call*/BLOCKS::M.clone(), /*enum_call*/BLOCKS::H.clone()), (/*enum_call*/BLOCKS::H.clone(), /*enum_call*/BLOCKS::I.clone()), (/*enum_call*/BLOCKS::I.clone(), /*enum_call*/BLOCKS::J.clone()), (/*enum_call*/BLOCKS::J.clone(), /*enum_call*/BLOCKS::N.clone())].clone()), (/*enum_call*/ROUTES::R6.clone(), brel![rel_BLOCKS_X_BLOCKS, (/*enum_call*/BLOCKS::C.clone(), /*enum_call*/BLOCKS::B.clone()), (/*enum_call*/BLOCKS::B.clone(), /*enum_call*/BLOCKS::A.clone()), (/*enum_call*/BLOCKS::A.clone(), /*enum_call*/BLOCKS::L.clone())].clone()), (/*enum_call*/ROUTES::R7.clone(), brel![rel_BLOCKS_X_BLOCKS, (/*enum_call*/BLOCKS::G.clone(), /*enum_call*/BLOCKS::F.clone()), (/*enum_call*/BLOCKS::F.clone(), /*enum_call*/BLOCKS::E.clone()), (/*enum_call*/BLOCKS::E.clone(), /*enum_call*/BLOCKS::D.clone()), (/*enum_call*/BLOCKS::D.clone(), /*enum_call*/BLOCKS::B.clone()), (/*enum_call*/BLOCKS::B.clone(), /*enum_call*/BLOCKS::A.clone()), (/*enum_call*/BLOCKS::A.clone(), /*enum_call*/BLOCKS::L.clone())].clone()), (/*enum_call*/ROUTES::R8.clone(), brel![rel_BLOCKS_X_BLOCKS, (/*enum_call*/BLOCKS::N.clone(), /*enum_call*/BLOCKS::J.clone()), (/*enum_call*/BLOCKS::J.clone(), /*enum_call*/BLOCKS::K.clone()), (/*enum_call*/BLOCKS::K.clone(), /*enum_call*/BLOCKS::D.clone()), (/*enum_call*/BLOCKS::D.clone(), /*enum_call*/BLOCKS::B.clone()), (/*enum_call*/BLOCKS::B.clone(), /*enum_call*/BLOCKS::A.clone()), (/*enum_call*/BLOCKS::A.clone(), /*enum_call*/BLOCKS::L.clone())].clone()), (/*enum_call*/ROUTES::R9.clone(), brel![rel_BLOCKS_X_BLOCKS, (/*enum_call*/BLOCKS::G.clone(), /*enum_call*/BLOCKS::F.clone()), (/*enum_call*/BLOCKS::F.clone(), /*enum_call*/BLOCKS::K.clone()), (/*enum_call*/BLOCKS::K.clone(), /*enum_call*/BLOCKS::I.clone()), (/*enum_call*/BLOCKS::I.clone(), /*enum_call*/BLOCKS::H.clone()), (/*enum_call*/BLOCKS::H.clone(), /*enum_call*/BLOCKS::M.clone())].clone()), (/*enum_call*/ROUTES::R10.clone(), brel![rel_BLOCKS_X_BLOCKS, (/*enum_call*/BLOCKS::N.clone(), /*enum_call*/BLOCKS::J.clone()), (/*enum_call*/BLOCKS::J.clone(), /*enum_call*/BLOCKS::I.clone()), (/*enum_call*/BLOCKS::I.clone(), /*enum_call*/BLOCKS::H.clone()), (/*enum_call*/BLOCKS::H.clone(), /*enum_call*/BLOCKS::M.clone())].clone())];
+ //constant_initialization
+ self.fst = brel![rel_ROUTES_X_BLOCKS, (/*enum_call*/ROUTES::R1.clone(), /*enum_call*/BLOCKS::L.clone()), (/*enum_call*/ROUTES::R2.clone(), /*enum_call*/BLOCKS::L.clone()), (/*enum_call*/ROUTES::R3.clone(), /*enum_call*/BLOCKS::L.clone()), (/*enum_call*/ROUTES::R4.clone(), /*enum_call*/BLOCKS::M.clone()), (/*enum_call*/ROUTES::R5.clone(), /*enum_call*/BLOCKS::M.clone()), (/*enum_call*/ROUTES::R6.clone(), /*enum_call*/BLOCKS::C.clone()), (/*enum_call*/ROUTES::R7.clone(), /*enum_call*/BLOCKS::G.clone()), (/*enum_call*/ROUTES::R8.clone(), /*enum_call*/BLOCKS::N.clone()), (/*enum_call*/ROUTES::R9.clone(), /*enum_call*/BLOCKS::G.clone()), (/*enum_call*/ROUTES::R10.clone(), /*enum_call*/BLOCKS::N.clone())];
+ //constant_initialization
+ self.lst = brel![rel_ROUTES_X_BLOCKS, (/*enum_call*/ROUTES::R1.clone(), /*enum_call*/BLOCKS::C.clone()), (/*enum_call*/ROUTES::R2.clone(), /*enum_call*/BLOCKS::G.clone()), (/*enum_call*/ROUTES::R3.clone(), /*enum_call*/BLOCKS::N.clone()), (/*enum_call*/ROUTES::R4.clone(), /*enum_call*/BLOCKS::G.clone()), (/*enum_call*/ROUTES::R5.clone(), /*enum_call*/BLOCKS::N.clone()), (/*enum_call*/ROUTES::R6.clone(), /*enum_call*/BLOCKS::L.clone()), (/*enum_call*/ROUTES::R7.clone(), /*enum_call*/BLOCKS::L.clone()), (/*enum_call*/ROUTES::R8.clone(), /*enum_call*/BLOCKS::L.clone()), (/*enum_call*/ROUTES::R9.clone(), /*enum_call*/BLOCKS::M.clone()), (/*enum_call*/ROUTES::R10.clone(), /*enum_call*/BLOCKS::M.clone())];
+ //constant_initialization
+ let mut _ic_set_0 = rel_BLOCKS_X_ROUTES::empty();
+ //iteration_construct_enumeration
+ for _ic_b_1 in self._BLOCKS.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_r_1 in self._ROUTES.clone().iter() {
+ //set_comprehension_predicate
+ if (self.nxt.domain().elementOf(&_ic_r_1) && (self.nxt.functionCall(&_ic_r_1).domain().elementOf(&_ic_b_1) || self.nxt.functionCall(&_ic_r_1).range().elementOf(&_ic_b_1))) {
+ _ic_set_0 = _ic_set_0.union(&brel![rel_BLOCKS_X_ROUTES, (_ic_b_1.clone(), _ic_r_1.clone())]);
+ }
+
+ }
+ }
+ self.rtbl = _ic_set_0;
+ /*body*/self.resrt = bset![ROUTES].clone().clone();
+ self.resbl = bset![BLOCKS].clone().clone();
+ self.rsrtbl = brel![rel_BLOCKS_X_ROUTES].clone().clone();
+ self.OCC = bset![BLOCKS].clone().clone();
+ self.TRK = brel![rel_BLOCKS_X_BLOCKS].clone().clone();
+ self.frm = bset![ROUTES].clone().clone();
+ self.LBT = bset![BLOCKS].clone().clone();
+ /*includesInitialization*/
+ }
+
+ pub fn get_fst(&self) -> rel_ROUTES_X_BLOCKS {
+ return self.fst.clone();
+ }
+
+ pub fn get_lst(&self) -> rel_ROUTES_X_BLOCKS {
+ return self.lst.clone();
+ }
+
+ pub fn get_nxt(&self) -> rel_ROUTES_X_SetBLOCKS_X_BLOCKS {
+ return self.nxt.clone();
+ }
+
+ pub fn get_rtbl(&self) -> rel_BLOCKS_X_ROUTES {
+ return self.rtbl.clone();
+ }
+
+ pub fn get_LBT(&self) -> set_BLOCKS {
+ return self.LBT.clone();
+ }
+
+ pub fn get_TRK(&self) -> rel_BLOCKS_X_BLOCKS {
+ return self.TRK.clone();
+ }
+
+ pub fn get_frm(&self) -> set_ROUTES {
+ return self.frm.clone();
+ }
+
+ pub fn get_OCC(&self) -> set_BLOCKS {
+ return self.OCC.clone();
+ }
+
+ pub fn get_resbl(&self) -> set_BLOCKS {
+ return self.resbl.clone();
+ }
+
+ pub fn get_resrt(&self) -> set_ROUTES {
+ return self.resrt.clone();
+ }
+
+ pub fn get_rsrtbl(&self) -> rel_BLOCKS_X_ROUTES {
+ return self.rsrtbl.clone();
+ }
+
+ pub fn get__BLOCKS(&self) -> set_BLOCKS {
+ return self._BLOCKS.clone();
+ }
+
+ pub fn get__ROUTES(&self) -> set_ROUTES {
+ return self._ROUTES.clone();
+ }
+
+ pub fn route_reservation(&mut self, mut r: ROUTES) -> () {
+ //pre_assert
+ let mut _ld_resrt = self.resrt.clone();
+ let mut _ld_rsrtbl = self.rsrtbl.clone();
+ let mut _ld_resbl = self.resbl.clone();
+ self.resrt = _ld_resrt.union(&bset![ROUTES, r]).clone().clone();
+ self.rsrtbl = _ld_rsrtbl.union(&self.rtbl.rangeRestriction(&bset![ROUTES, r])).clone().clone();
+ self.resbl = _ld_resbl.union(&self.rtbl.inverse().relationImage(&bset![ROUTES, r])).clone().clone();
+
+ }
+
+ pub fn route_freeing(&mut self, mut r: ROUTES) -> () {
+ //pre_assert
+ let mut _ld_frm = self.frm.clone();
+ let mut _ld_resrt = self.resrt.clone();
+ self.resrt = _ld_resrt.difference(&bset![ROUTES, r]).clone().clone();
+ self.frm = _ld_frm.difference(&bset![ROUTES, r]).clone().clone();
+
+ }
+
+ pub fn FRONT_MOVE_1(&mut self, mut r: ROUTES) -> () {
+ //pre_assert
+ let mut _ld_OCC = self.OCC.clone();
+ let mut _ld_LBT = self.LBT.clone();
+ self.OCC = _ld_OCC.union(&bset![BLOCKS, self.fst.functionCall(&r)]).clone().clone();
+ self.LBT = _ld_LBT.union(&bset![BLOCKS, self.fst.functionCall(&r)]).clone().clone();
+
+ }
+
+ pub fn FRONT_MOVE_2(&mut self, mut b: BLOCKS) -> () {
+ //pre_assert
+ self.OCC = self.OCC.union(&bset![BLOCKS, self.TRK.functionCall(&b)]).clone().clone();
+
+ }
+
+ pub fn BACK_MOVE_1(&mut self, mut b: BLOCKS) -> () {
+ //pre_assert
+ let mut _ld_rsrtbl = self.rsrtbl.clone();
+ let mut _ld_resbl = self.resbl.clone();
+ let mut _ld_OCC = self.OCC.clone();
+ let mut _ld_LBT = self.LBT.clone();
+ self.OCC = _ld_OCC.difference(&bset![BLOCKS, b]).clone().clone();
+ self.rsrtbl = _ld_rsrtbl.domainSubstraction(&bset![BLOCKS, b]).clone().clone();
+ self.resbl = _ld_resbl.difference(&bset![BLOCKS, b]).clone().clone();
+ self.LBT = _ld_LBT.difference(&bset![BLOCKS, b]).clone().clone();
+
+ }
+
+ pub fn BACK_MOVE_2(&mut self, mut b: BLOCKS) -> () {
+ //pre_assert
+ let mut _ld_rsrtbl = self.rsrtbl.clone();
+ let mut _ld_resbl = self.resbl.clone();
+ let mut _ld_OCC = self.OCC.clone();
+ let mut _ld_LBT = self.LBT.clone();
+ self.OCC = _ld_OCC.difference(&bset![BLOCKS, b]).clone().clone();
+ self.rsrtbl = _ld_rsrtbl.domainSubstraction(&bset![BLOCKS, b]).clone().clone();
+ self.resbl = _ld_resbl.difference(&bset![BLOCKS, b]).clone().clone();
+ self.LBT = _ld_LBT.difference(&bset![BLOCKS, b]).union(&bset![BLOCKS, self.TRK.functionCall(&b)]).clone().clone();
+
+ }
+
+ pub fn point_positionning(&mut self, mut r: ROUTES) -> () {
+ //pre_assert
+ self.TRK = self.TRK.domainSubstraction(&self.nxt.functionCall(&r).domain()).rangeSubstraction(&self.nxt.functionCall(&r).range()).union(&self.nxt.functionCall(&r)).clone().clone();
+
+ }
+
+ pub fn route_formation(&mut self, mut r: ROUTES) -> () {
+ //pre_assert
+ self.frm = self.frm.union(&bset![ROUTES, r]).clone().clone();
+
+ }
+
+ pub fn _tr_route_reservation(&mut self, is_caching: bool) -> HashSet<ROUTES> {
+ //transition
+ if !is_caching || self._tr_cache_route_reservation.is_none() {
+ let mut _ic_set_1: HashSet<ROUTES> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_r_1 in self._ROUTES.difference(&self.resrt).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if (self.rtbl.inverse().relationImage(&bset![ROUTES, _ic_r_1]).intersect(&self.resbl).equal(&bset![BLOCKS]) && bset![ROUTES].equal(&self.resrt.difference(&self.rsrtbl.range()))) {
+ _ic_set_1.insert(_ic_r_1);
+ }
+
+ }
+ self._tr_cache_route_reservation = Option::Some(_ic_set_1.clone());
+ return _ic_set_1;
+ } else {
+ return self._tr_cache_route_reservation.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_route_freeing(&mut self, is_caching: bool) -> HashSet<ROUTES> {
+ //transition
+ if !is_caching || self._tr_cache_route_freeing.is_none() {
+ let mut _ic_set_2: HashSet<ROUTES> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_r_1 in self.resrt.difference(&self.rsrtbl.range()).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ _ic_set_2.insert(_ic_r_1);
+
+ }
+ self._tr_cache_route_freeing = Option::Some(_ic_set_2.clone());
+ return _ic_set_2;
+ } else {
+ return self._tr_cache_route_freeing.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_FRONT_MOVE_1(&mut self, is_caching: bool) -> HashSet<ROUTES> {
+ //transition
+ if !is_caching || self._tr_cache_FRONT_MOVE_1.is_none() {
+ let mut _ic_set_3: HashSet<ROUTES> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_r_1 in self.frm.clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if ((self.resbl.difference(&self.OCC).elementOf(&self.fst.functionCall(&_ic_r_1)) && _ic_r_1.equal(&self.rsrtbl.functionCall(&self.fst.functionCall(&_ic_r_1)))) && bset![ROUTES].equal(&self.resrt.difference(&self.rsrtbl.range()))) {
+ _ic_set_3.insert(_ic_r_1);
+ }
+
+ }
+ self._tr_cache_FRONT_MOVE_1 = Option::Some(_ic_set_3.clone());
+ return _ic_set_3;
+ } else {
+ return self._tr_cache_FRONT_MOVE_1.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_FRONT_MOVE_2(&mut self, is_caching: bool) -> HashSet<BLOCKS> {
+ //transition
+ if !is_caching || self._tr_cache_FRONT_MOVE_2.is_none() {
+ let mut _ic_set_4: HashSet<BLOCKS> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_b_1 in self.OCC.intersect(&self.TRK.domain()).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if self.OCC.notElementOf(&self.TRK.functionCall(&_ic_b_1)) {
+ _ic_set_4.insert(_ic_b_1);
+ }
+
+ }
+ self._tr_cache_FRONT_MOVE_2 = Option::Some(_ic_set_4.clone());
+ return _ic_set_4;
+ } else {
+ return self._tr_cache_FRONT_MOVE_2.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_BACK_MOVE_1(&mut self, is_caching: bool) -> HashSet<BLOCKS> {
+ //transition
+ if !is_caching || self._tr_cache_BACK_MOVE_1.is_none() {
+ let mut _ic_set_5: HashSet<BLOCKS> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_b_1 in self.LBT.difference(&self.TRK.domain()).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if bset![ROUTES].equal(&self.resrt.difference(&self.rsrtbl.range())) {
+ _ic_set_5.insert(_ic_b_1);
+ }
+
+ }
+ self._tr_cache_BACK_MOVE_1 = Option::Some(_ic_set_5.clone());
+ return _ic_set_5;
+ } else {
+ return self._tr_cache_BACK_MOVE_1.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_BACK_MOVE_2(&mut self, is_caching: bool) -> HashSet<BLOCKS> {
+ //transition
+ if !is_caching || self._tr_cache_BACK_MOVE_2.is_none() {
+ let mut _ic_set_6: HashSet<BLOCKS> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_b_1 in self.LBT.intersect(&self.TRK.domain()).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if (self.OCC.elementOf(&self.TRK.functionCall(&_ic_b_1)) && bset![ROUTES].equal(&self.resrt.difference(&self.rsrtbl.range()))) {
+ _ic_set_6.insert(_ic_b_1);
+ }
+
+ }
+ self._tr_cache_BACK_MOVE_2 = Option::Some(_ic_set_6.clone());
+ return _ic_set_6;
+ } else {
+ return self._tr_cache_BACK_MOVE_2.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_point_positionning(&mut self, is_caching: bool) -> HashSet<ROUTES> {
+ //transition
+ if !is_caching || self._tr_cache_point_positionning.is_none() {
+ let mut _ic_set_7: HashSet<ROUTES> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_r_1 in self.resrt.difference(&self.frm).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if bset![ROUTES].equal(&self.resrt.difference(&self.rsrtbl.range())) {
+ _ic_set_7.insert(_ic_r_1);
+ }
+
+ }
+ self._tr_cache_point_positionning = Option::Some(_ic_set_7.clone());
+ return _ic_set_7;
+ } else {
+ return self._tr_cache_point_positionning.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_route_formation(&mut self, is_caching: bool) -> HashSet<ROUTES> {
+ //transition
+ if !is_caching || self._tr_cache_route_formation.is_none() {
+ let mut _ic_set_8: HashSet<ROUTES> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_r_1 in self.resrt.difference(&self.frm).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if (self.nxt.functionCall(&_ic_r_1).domainRestriction(&self.rsrtbl.inverse().relationImage(&bset![ROUTES, _ic_r_1])).equal(&self.TRK.domainRestriction(&self.rsrtbl.inverse().relationImage(&bset![ROUTES, _ic_r_1]))) && bset![ROUTES].equal(&self.resrt.difference(&self.rsrtbl.range()))) {
+ _ic_set_8.insert(_ic_r_1);
+ }
+
+ }
+ self._tr_cache_route_formation = Option::Some(_ic_set_8.clone());
+ return _ic_set_8;
+ } else {
+ return self._tr_cache_route_formation.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _check_inv_1(&self) -> bool {
+ //invariant
+ return self._BLOCKS.check_domain_of(&self.TRK).and(&self._BLOCKS.check_range_of(&self.TRK)).and(&self.TRK.isFunction()).and(&self._BLOCKS.check_partial_of(&self.TRK)).and(&self.TRK.isInjection());
+ }
+
+ pub fn _check_inv_2(&self) -> bool {
+ //invariant
+ //quantified_predicate
+ let mut _ic_boolean_9 = true;
+ //iteration_construct_enumeration
+ for _ic_r_1 in self.resrt.difference(&self.frm).clone().iter() {
+ //iteration_construct_assignment
+ {
+ let mut _ic_a_1 = bset![ROUTES, _ic_r_1];
+ if !self.rtbl.rangeRestriction(&_ic_a_1).equal(&self.rsrtbl.rangeRestriction(&_ic_a_1)) {
+ _ic_boolean_9 = false;
+ break;
+ }
+
+ }
+ }
+
+ return _ic_boolean_9;
+ }
+
+ pub fn _check_inv_3(&self) -> bool {
+ //invariant
+ //quantified_predicate
+ let mut _ic_boolean_11 = true;
+ //iteration_construct_enumeration
+ for _ic_x_1 in self.TRK.domain().clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_y_1 in self.TRK.relationImage(&bset![BLOCKS, _ic_x_1]).clone().iter() {
+ //quantified_predicate
+ let mut _ic_boolean_10 = false;
+ //iteration_construct_enumeration
+ for _ic_r_1 in self._ROUTES.clone().iter() {
+ if self.nxt.functionCall(&_ic_r_1).elementOf(&(_ic_x_1.clone(), _ic_y_1.clone())) {
+ _ic_boolean_10 = true;
+ break;
+ }
+
+ }
+
+ if !_ic_boolean_10 {
+ _ic_boolean_11 = false;
+ break;
+ }
+
+ }
+ }
+
+ return _ic_boolean_11;
+ }
+
+ pub fn _check_inv_4(&self) -> bool {
+ //invariant
+ //quantified_predicate
+ let mut _ic_boolean_12 = true;
+ //iteration_construct_enumeration
+ for _ic_r_1 in self.frm.clone().iter() {
+ //iteration_construct_assignment
+ {
+ let mut _ic_a_1 = self.rsrtbl.inverse().relationImage(&bset![ROUTES, _ic_r_1]);
+ if !self.nxt.functionCall(&_ic_r_1).domainRestriction(&_ic_a_1).equal(&self.TRK.domainRestriction(&_ic_a_1)) {
+ _ic_boolean_12 = false;
+ break;
+ }
+
+ }
+ }
+
+ return _ic_boolean_12;
+ }
+
+ pub fn _check_inv_5(&self) -> bool {
+ //invariant
+ return self.LBT.subset(&self.OCC);
+ }
+
+ pub fn _check_inv_6(&self) -> bool {
+ //invariant
+ //quantified_predicate
+ let mut _ic_boolean_13 = true;
+ //iteration_construct_enumeration
+ for _ic_a_1 in self.rsrtbl.domain().clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_b_1 in self.LBT.clone().iter() {
+ //iteration_construct_assignment
+ {
+ let mut _ic_c_1 = self.rsrtbl.functionCall(&_ic_b_1);
+ //iteration_construct_assignment
+ {
+ let mut _ic_d_1 = self.nxt.functionCall(&_ic_c_1);
+ if !(_ic_d_1.range().elementOf(&_ic_b_1) && _ic_a_1.equal(&_ic_d_1.inverse().functionCall(&_ic_b_1))).implies(|| self.rsrtbl.functionCall(&_ic_a_1).unequal(&_ic_c_1)) {
+ _ic_boolean_13 = false;
+ break;
+ }
+
+ }
+ }
+ }
+ }
+
+ return _ic_boolean_13;
+ }
+
+ pub fn _check_inv_7(&self) -> bool {
+ //invariant
+ return self.resbl.check_domain_of(&self.rsrtbl).and(&self.resrt.check_range_of(&self.rsrtbl)).and(&self.rsrtbl.isFunction()).and(&self.resbl.check_total_of(&self.rsrtbl));
+ }
+
+ pub fn _check_inv_8(&self) -> bool {
+ //invariant
+ return self.rsrtbl.subset(&self.rtbl);
+ }
+
+ pub fn _check_inv_9(&self) -> bool {
+ //invariant
+ return self.OCC.subset(&self.resbl);
+ }
+
+ pub fn _check_inv_10(&self) -> bool {
+ //invariant
+ //quantified_predicate
+ let mut _ic_boolean_14 = true;
+ //iteration_construct_enumeration
+ for _ic_r_1 in self._ROUTES.clone().iter() {
+ //iteration_construct_assignment
+ {
+ let mut _ic_a_1 = self.nxt.functionCall(&_ic_r_1);
+ //iteration_construct_assignment
+ {
+ let mut _ic_b_1 = self.rsrtbl.inverse().relationImage(&bset![ROUTES, _ic_r_1]);
+ //iteration_construct_assignment
+ {
+ let mut _ic_c_1 = _ic_b_1.difference(&self.OCC);
+ if !((_ic_a_1.relationImage(&self.rtbl.inverse().relationImage(&bset![ROUTES, _ic_r_1]).difference(&_ic_b_1)).intersect(&_ic_c_1).equal(&bset![BLOCKS]) && _ic_a_1.relationImage(&_ic_b_1).subset(&_ic_b_1)) && _ic_a_1.relationImage(&_ic_c_1).subset(&_ic_c_1)) {
+ _ic_boolean_14 = false;
+ break;
+ }
+
+ }
+ }
+ }
+ }
+
+ return _ic_boolean_14;
+ }
+
+ pub fn _check_inv_11(&self) -> bool {
+ //invariant
+ return self.frm.subset(&self.resrt);
+ }
+
+ pub fn _check_inv_12(&self) -> bool {
+ //invariant
+ return self.rsrtbl.relationImage(&self.OCC).subset(&self.frm);
+ }
+
+ fn invalidate_caches(&mut self, to_invalidate: Vec<&'static str>) {
+ //calling the given functions without caching will recalculate them and cache them afterwards
+ for trans in to_invalidate {
+ match trans {
+ "_tr_route_reservation" => {self._tr_route_reservation(false);},
+ "_tr_route_freeing" => {self._tr_route_freeing(false);},
+ "_tr_FRONT_MOVE_1" => {self._tr_FRONT_MOVE_1(false);},
+ "_tr_FRONT_MOVE_2" => {self._tr_FRONT_MOVE_2(false);},
+ "_tr_BACK_MOVE_1" => {self._tr_BACK_MOVE_1(false);},
+ "_tr_BACK_MOVE_2" => {self._tr_BACK_MOVE_2(false);},
+ "_tr_point_positionning" => {self._tr_point_positionning(false);},
+ "_tr_route_formation" => {self._tr_route_formation(false);},
+ _ => {},
+ }
+ }
+ }
+
+ //model_check_next_states
+ fn generateNextStates(state: &mut Train_1_beebook_deterministic_MC_POR_v2,
+ isCaching: bool,
+ transitions: Arc<AtomicU64>) -> HashSet<(Train_1_beebook_deterministic_MC_POR_v2, &'static str)> {
+ let mut result = HashSet::<(Train_1_beebook_deterministic_MC_POR_v2, &'static str)>::new();
+ let mut evaluated_transitions: u64 = 0;
+ //model_check_transition
+ let mut _trid_1 = state._tr_route_reservation(isCaching);
+ for param in _trid_1.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.route_reservation(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("route_reservation")); }
+ result.insert((copiedState, "route_reservation"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_2 = state._tr_route_freeing(isCaching);
+ for param in _trid_2.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.route_freeing(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("route_freeing")); }
+ result.insert((copiedState, "route_freeing"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_3 = state._tr_FRONT_MOVE_1(isCaching);
+ for param in _trid_3.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.FRONT_MOVE_1(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("FRONT_MOVE_1")); }
+ result.insert((copiedState, "FRONT_MOVE_1"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_4 = state._tr_FRONT_MOVE_2(isCaching);
+ for param in _trid_4.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.FRONT_MOVE_2(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("FRONT_MOVE_2")); }
+ result.insert((copiedState, "FRONT_MOVE_2"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_5 = state._tr_BACK_MOVE_1(isCaching);
+ for param in _trid_5.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.BACK_MOVE_1(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("BACK_MOVE_1")); }
+ result.insert((copiedState, "BACK_MOVE_1"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_6 = state._tr_BACK_MOVE_2(isCaching);
+ for param in _trid_6.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.BACK_MOVE_2(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("BACK_MOVE_2")); }
+ result.insert((copiedState, "BACK_MOVE_2"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_7 = state._tr_point_positionning(isCaching);
+ for param in _trid_7.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.point_positionning(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("point_positionning")); }
+ result.insert((copiedState, "point_positionning"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_8 = state._tr_route_formation(isCaching);
+ for param in _trid_8.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.route_formation(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("route_formation")); }
+ result.insert((copiedState, "route_formation"));
+ evaluated_transitions += 1;
+ }
+
+
+ transitions.fetch_add(evaluated_transitions, Ordering::AcqRel);
+ return result;
+ }
+
+ //model_check_invariants
+ pub fn checkInvariants(state: &Train_1_beebook_deterministic_MC_POR_v2, last_op: &'static str, isCaching: bool) -> bool {
+ if isCaching {
+ let dependent_invariants_of_state = Self::get_invariant_dependencies(last_op);
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_1") {
+ if !state._check_inv_1() {
+ println!("_check_inv_1 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_2") {
+ if !state._check_inv_2() {
+ println!("_check_inv_2 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_3") {
+ if !state._check_inv_3() {
+ println!("_check_inv_3 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_4") {
+ if !state._check_inv_4() {
+ println!("_check_inv_4 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_5") {
+ if !state._check_inv_5() {
+ println!("_check_inv_5 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_6") {
+ if !state._check_inv_6() {
+ println!("_check_inv_6 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_7") {
+ if !state._check_inv_7() {
+ println!("_check_inv_7 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_8") {
+ if !state._check_inv_8() {
+ println!("_check_inv_8 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_9") {
+ if !state._check_inv_9() {
+ println!("_check_inv_9 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_10") {
+ if !state._check_inv_10() {
+ println!("_check_inv_10 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_11") {
+ if !state._check_inv_11() {
+ println!("_check_inv_11 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_12") {
+ if !state._check_inv_12() {
+ println!("_check_inv_12 failed!");
+ return false;
+ }
+ }
+ return true;
+ }
+ return !(!state._check_inv_1() || !state._check_inv_2() || !state._check_inv_3() || !state._check_inv_4() || !state._check_inv_5() || !state._check_inv_6() || !state._check_inv_7() || !state._check_inv_8() || !state._check_inv_9() || !state._check_inv_10() || !state._check_inv_11() || !state._check_inv_12());
+ }
+
+ //model_check_print
+ fn print_result(states: usize, transitions: u64, error_detected: bool) {
+ if !error_detected { println!("MODEL CHECKING SUCCESSFUL"); }
+ println!("Number of States: {}", states);
+ println!("Number of Transitions: {}", transitions);
+ }
+
+ //model_check_main
+ fn next(collection_m: Arc<Mutex<LinkedList<(Train_1_beebook_deterministic_MC_POR_v2, &'static str)>>>, mc_type: MC_TYPE) -> (Train_1_beebook_deterministic_MC_POR_v2, &'static str) {
+ let mut collection = collection_m.lock().unwrap();
+ return match mc_type {
+ MC_TYPE::BFS => collection.pop_front().unwrap(),
+ MC_TYPE::DFS => collection.pop_back().unwrap(),
+ MC_TYPE::MIXED => if collection.len() % 2 == 0 { collection.pop_front().unwrap() } else { collection.pop_back().unwrap() }
+ };
+ }
+
+ fn get_guard_dependencies(op: &'static str) -> Vec<&str> {
+ return match op {
+ //model_check_init_static
+ "point_positionning" => vec!["_tr_route_formation", "_tr_BACK_MOVE_1", "_tr_FRONT_MOVE_2", "_tr_BACK_MOVE_2"],
+ //model_check_init_static
+ "route_reservation" => vec!["_tr_route_formation", "_tr_FRONT_MOVE_1", "_tr_route_reservation", "_tr_route_freeing", "_tr_BACK_MOVE_1", "_tr_point_positionning", "_tr_BACK_MOVE_2"],
+ //model_check_init_static
+ "FRONT_MOVE_1" => vec!["_tr_FRONT_MOVE_1", "_tr_BACK_MOVE_1", "_tr_FRONT_MOVE_2", "_tr_BACK_MOVE_2"],
+ //model_check_init_static
+ "BACK_MOVE_1" => vec!["_tr_route_formation", "_tr_FRONT_MOVE_1", "_tr_route_reservation", "_tr_route_freeing", "_tr_BACK_MOVE_1", "_tr_point_positionning", "_tr_FRONT_MOVE_2", "_tr_BACK_MOVE_2"],
+ //model_check_init_static
+ "FRONT_MOVE_2" => vec!["_tr_FRONT_MOVE_1", "_tr_FRONT_MOVE_2", "_tr_BACK_MOVE_2"],
+ //model_check_init_static
+ "route_formation" => vec!["_tr_route_formation", "_tr_FRONT_MOVE_1", "_tr_point_positionning"],
+ //model_check_init_static
+ "route_freeing" => vec!["_tr_route_formation", "_tr_FRONT_MOVE_1", "_tr_route_reservation", "_tr_route_freeing", "_tr_BACK_MOVE_1", "_tr_point_positionning", "_tr_BACK_MOVE_2"],
+ //model_check_init_static
+ "BACK_MOVE_2" => vec!["_tr_route_formation", "_tr_FRONT_MOVE_1", "_tr_route_reservation", "_tr_route_freeing", "_tr_BACK_MOVE_1", "_tr_point_positionning", "_tr_FRONT_MOVE_2", "_tr_BACK_MOVE_2"],
+ _ => vec![],
+ }
+ }
+
+ fn get_invariant_dependencies(op: &'static str) -> Vec<&str> {
+ return match op {
+ //model_check_init_static
+ "point_positionning" => vec!["_check_inv_3", "_check_inv_1", "_check_inv_4"],
+ //model_check_init_static
+ "route_reservation" => vec!["_check_inv_2", "_check_inv_6", "_check_inv_10", "_check_inv_7", "_check_inv_4", "_check_inv_8", "_check_inv_12", "_check_inv_9", "_check_inv_11"],
+ //model_check_init_static
+ "FRONT_MOVE_1" => vec!["_check_inv_6", "_check_inv_10", "_check_inv_5", "_check_inv_12", "_check_inv_9"],
+ //model_check_init_static
+ "BACK_MOVE_1" => vec!["_check_inv_2", "_check_inv_6", "_check_inv_10", "_check_inv_7", "_check_inv_4", "_check_inv_5", "_check_inv_8", "_check_inv_12", "_check_inv_9"],
+ //model_check_init_static
+ "FRONT_MOVE_2" => vec!["_check_inv_10", "_check_inv_5", "_check_inv_12", "_check_inv_9"],
+ //model_check_init_static
+ "route_formation" => vec!["_check_inv_2", "_check_inv_4", "_check_inv_12", "_check_inv_11"],
+ //model_check_init_static
+ "route_freeing" => vec!["_check_inv_2", "_check_inv_7", "_check_inv_4", "_check_inv_12", "_check_inv_11"],
+ //model_check_init_static
+ "BACK_MOVE_2" => vec!["_check_inv_2", "_check_inv_6", "_check_inv_10", "_check_inv_7", "_check_inv_4", "_check_inv_5", "_check_inv_8", "_check_inv_12", "_check_inv_9"],
+ _ => vec![],
+ }
+ }
+
+ fn model_check_single_threaded(mc_type: MC_TYPE, is_caching: bool, no_dead: bool, no_inv: bool) {
+ let mut machine = Train_1_beebook_deterministic_MC_POR_v2::new();
+
+ let mut all_states = HashSet::<Train_1_beebook_deterministic_MC_POR_v2>::new();
+ all_states.insert(machine.clone());
+
+ let states_to_process_mutex = Arc::new(Mutex::new(LinkedList::<(Train_1_beebook_deterministic_MC_POR_v2, &'static str)>::new()));
+ states_to_process_mutex.lock().unwrap().push_back((machine.clone(), ""));
+
+ let num_transitions = Arc::new(AtomicU64::new(0));
+
+ let mut stop_threads = false;
+
+ while !stop_threads && !states_to_process_mutex.lock().unwrap().is_empty() {
+ let (mut state, last_op) = Self::next(Arc::clone(&states_to_process_mutex), mc_type);
+
+ let next_states = Self::generateNextStates(&mut state, is_caching, Arc::clone(&num_transitions));
+
+ if !no_inv && !Self::checkInvariants(&state, last_op, is_caching) {
+ println!("INVARIANT VIOLATED");
+ stop_threads = true;
+ }
+ if !no_dead && next_states.is_empty() {
+ print!("DEADLOCK DETECTED");
+ stop_threads = true;
+ }
+
+ next_states.into_iter()
+ .filter(|(next_state, _)| all_states.insert((*next_state).clone()))
+ .for_each(|(next_state, last_op)| states_to_process_mutex.lock().unwrap().push_back((next_state, last_op)));
+
+ if all_states.len() % 50000 == 0 {
+ println!("VISITED STATES: {}", all_states.len());
+ println!("EVALUATED TRANSITIONS: {}", num_transitions.load(Ordering::Acquire));
+ println!("-------------------");
+ }
+ }
+ Self::print_result(all_states.len(), num_transitions.load(Ordering::Acquire), stop_threads);
+ }
+
+ fn modelCheckMultiThreaded(mc_type: MC_TYPE, threads: usize, is_caching: bool, no_dead: bool, no_inv: bool) {
+ let threadPool = ThreadPool::new(threads);
+
+ let machine = Train_1_beebook_deterministic_MC_POR_v2::new();
+
+ let all_states = Arc::new(DashSet::<Train_1_beebook_deterministic_MC_POR_v2>::new());
+ all_states.insert(machine.clone());
+
+ let states_to_process_mutex = Arc::new(Mutex::new(LinkedList::<(Train_1_beebook_deterministic_MC_POR_v2, &'static str)>::new()));
+ states_to_process_mutex.lock().unwrap().push_back((machine, ""));
+
+ let num_transitions = Arc::new(AtomicU64::new(0));
+
+ let mut stop_threads = false;
+ let mut spawned_tasks: u64 = 0;
+ let mut finished_tasks: u64 = 0;
+
+ let (tx, rx) = channel();
+ //println!("Thread {:?} starting threads", thread::current().id());
+ while !stop_threads && !states_to_process_mutex.lock().unwrap().is_empty() {
+ let (mut state, last_op) = Self::next(Arc::clone(&states_to_process_mutex), mc_type);
+
+ let states_to_process = Arc::clone(&states_to_process_mutex);
+ let transitions = Arc::clone(&num_transitions);
+ let states = Arc::clone(&all_states);
+ let tx = tx.clone();
+ //println!("Thread {:?} spawning a thread", thread::current().id());
+ threadPool.execute(move|| {
+ let next_states = Self::generateNextStates(&mut state, is_caching, transitions);
+ if !no_dead && next_states.is_empty() { let _ = tx.send(Err("DEADLOCK DETECTED")); }
+
+ //println!("Thread {:?} executing", thread::current().id());
+ next_states.into_iter()
+ .filter(|(next_state, _)| states.insert((*next_state).clone()))
+ .for_each(|(next_state, last_op)| states_to_process.lock().unwrap().push_back((next_state, last_op)));
+
+ if !no_inv && !Self::checkInvariants(&state, last_op, is_caching) {
+ let _ = tx.send(Err("INVARIANT VIOLATED"));
+ }
+ //println!("Thread {:?} done", thread::current().id());
+ let _ = tx.send(Ok(1));
+ });
+
+ spawned_tasks += 1;
+ if spawned_tasks % 50000 == 0 {
+ println!("VISITED STATES: {}", all_states.len());
+ println!("EVALUATED TRANSITIONS: {}", num_transitions.load(Ordering::Acquire));
+ println!("-------------------");
+ }
+
+ while states_to_process_mutex.lock().unwrap().is_empty() && spawned_tasks - finished_tasks > 0 {
+ //println!("Thread {:?} (main) waiting for a thread to finish", thread::current().id());
+ match rx.try_recv() {
+ Ok(val) => match val {
+ Ok(_) => finished_tasks += 1,
+ Err(msg) => { println!("{}", msg); stop_threads = true; },
+ },
+ Err(_) => (),
+ }
+ if threadPool.panic_count() > 0 { stop_threads = true; }
+ }
+ }
+
+ Self::print_result(all_states.len(), num_transitions.load(Ordering::Acquire), stop_threads);
+ }
+
+}
+
+
+fn main() {
+ let args: Vec<String> = env::args().collect();
+ if args.len() < 4 { panic!("Number of arguments errorneous"); }
+
+ let threads = args.get(2).unwrap().parse::<usize>().unwrap();
+ if threads <= 0 { panic!("Input for number of threads is wrong."); }
+
+ let is_caching = args.get(3).unwrap().parse::<bool>().unwrap();
+ let mc_type = match args.get(1).unwrap().as_str() {
+ "mixed" => MC_TYPE::MIXED,
+ "bf" => MC_TYPE::BFS,
+ "df" => MC_TYPE::DFS,
+ _ => panic!("Input for strategy is wrong.")
+ };
+
+ let mut no_dead = false;
+ let mut no_inv = false;
+
+ if args.len() > 4 {
+ for arg in args.iter().skip(4) {
+ match arg.as_str() {
+ "-nodead" => no_dead = true,
+ "-noinv" => no_inv = true,
+ _ => {}
+ }
+ }
+ }
+
+ if threads == 1 {
+ Train_1_beebook_deterministic_MC_POR_v2::model_check_single_threaded(mc_type, is_caching, no_dead, no_inv);
+ } else {
+ Train_1_beebook_deterministic_MC_POR_v2::modelCheckMultiThreaded(mc_type, threads, is_caching, no_dead, no_inv);
+ }
+}
diff --git a/benchmarks/model_checking/Rust_embedded/nota_v2.rs b/benchmarks/model_checking/Rust_embedded/nota_v2.rs
new file mode 100644
index 000000000..fc0d64c1a
--- /dev/null
+++ b/benchmarks/model_checking/Rust_embedded/nota_v2.rs
@@ -0,0 +1,2112 @@
+#![ allow( dead_code, unused, non_snake_case, non_camel_case_types, unused_assignments ) ]
+//#![no_std] //std is enabled for the generated machine by default, since without it there is no println which makes unit-testing very difficult
+use btypes::{bset, brel};
+use btypes::bset::BSet;
+use btypes::bset::SetItem;
+use btypes::bset::PowSetItem;
+use btypes::bset::PowAble;
+use btypes::bset::NestedSet;
+use btypes::brelation::BRelation;
+use btypes::brelation::RelLeftItem;
+use btypes::brelation::RelPowAble;
+use btypes::bboolean::BBoolean;
+use btypes::bboolean::BBool;
+use btypes::bboolean::BOOL;
+use btypes::binteger::BInteger;
+use btypes::binteger::BInt;
+use btypes::binteger::set_BInteger;
+use btypes::btuple::BTuple;
+
+use std::env;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, mpsc, Mutex};
+use std::collections::{HashSet, LinkedList};
+use dashmap::DashSet;
+use threadpool::ThreadPool;
+use std::sync::mpsc::channel;
+use derivative::Derivative;
+use std::time::{Duration};
+
+
+
+#[derive(Clone, Copy)]
+pub enum MC_TYPE { BFS, DFS, MIXED }
+
+#[derive(Default, Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct _Struct5 {
+ soc: set_SOCKET,
+ err: IN_ERROR_CODES,
+}
+
+impl _Struct5 {
+ pub fn new(mut soc: set_SOCKET, mut err: IN_ERROR_CODES) -> _Struct5 {
+ let mut m: _Struct5 = Default::default();
+ //record_field_initialization
+ m.soc = soc;//record_field_initialization
+ m.err = err;
+ return m;
+ }
+
+ //record_field_get
+ pub fn get_soc(&self) -> set_SOCKET {
+ return self.soc.clone();
+ }
+
+ //record_field_get
+ pub fn get_err(&self) -> IN_ERROR_CODES {
+ return self.err.clone();
+ }
+
+ //record_field_override
+ pub fn override_soc(&self, soc: set_SOCKET) -> _Struct5 {
+ return _Struct5::new(soc.clone(), self.err.clone());
+ }
+
+
+ //record_field_override
+ pub fn override_err(&self, err: IN_ERROR_CODES) -> _Struct5 {
+ return _Struct5::new(self.soc.clone(), err.clone());
+ }
+
+
+ pub fn equal(&self, other: &_Struct5) -> bool {
+ return self.soc == other.soc && self.err == other.err;
+ }
+
+ pub fn unequal(&self, other: &_Struct5) -> bool {
+ return self.soc != other.soc || self.err != other.err;
+ }
+
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct _Struct1 {
+ sid: set_SID,
+ err: RM_ERROR_CODES,
+}
+
+impl _Struct1 {
+ pub fn new(mut sid: set_SID, mut err: RM_ERROR_CODES) -> _Struct1 {
+ let mut m: _Struct1 = Default::default();
+ //record_field_initialization
+ m.sid = sid;//record_field_initialization
+ m.err = err;
+ return m;
+ }
+
+ //record_field_get
+ pub fn get_sid(&self) -> set_SID {
+ return self.sid.clone();
+ }
+
+ //record_field_get
+ pub fn get_err(&self) -> RM_ERROR_CODES {
+ return self.err.clone();
+ }
+
+ //record_field_override
+ pub fn override_sid(&self, sid: set_SID) -> _Struct1 {
+ return _Struct1::new(sid.clone(), self.err.clone());
+ }
+
+
+ //record_field_override
+ pub fn override_err(&self, err: RM_ERROR_CODES) -> _Struct1 {
+ return _Struct1::new(self.sid.clone(), err.clone());
+ }
+
+
+ pub fn equal(&self, other: &_Struct1) -> bool {
+ return self.sid == other.sid && self.err == other.err;
+ }
+
+ pub fn unequal(&self, other: &_Struct1) -> bool {
+ return self.sid != other.sid || self.err != other.err;
+ }
+
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct _Struct3 {
+ sid: set_SID,
+ err: IN_ERROR_CODES,
+}
+
+impl _Struct3 {
+ pub fn new(mut sid: set_SID, mut err: IN_ERROR_CODES) -> _Struct3 {
+ let mut m: _Struct3 = Default::default();
+ //record_field_initialization
+ m.sid = sid;//record_field_initialization
+ m.err = err;
+ return m;
+ }
+
+ //record_field_get
+ pub fn get_sid(&self) -> set_SID {
+ return self.sid.clone();
+ }
+
+ //record_field_get
+ pub fn get_err(&self) -> IN_ERROR_CODES {
+ return self.err.clone();
+ }
+
+ //record_field_override
+ pub fn override_sid(&self, sid: set_SID) -> _Struct3 {
+ return _Struct3::new(sid.clone(), self.err.clone());
+ }
+
+
+ //record_field_override
+ pub fn override_err(&self, err: IN_ERROR_CODES) -> _Struct3 {
+ return _Struct3::new(self.sid.clone(), err.clone());
+ }
+
+
+ pub fn equal(&self, other: &_Struct3) -> bool {
+ return self.sid == other.sid && self.err == other.err;
+ }
+
+ pub fn unequal(&self, other: &_Struct3) -> bool {
+ return self.sid != other.sid || self.err != other.err;
+ }
+
+}
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum INTERCONNECTNODE {
+ #[default]
+ node1 = 0,
+ node2 = 1
+}
+
+impl INTERCONNECTNODE {
+ pub fn equal(&self, other: &INTERCONNECTNODE) -> bool { *self == *other }
+ pub fn unequal(&self, other: &INTERCONNECTNODE) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::node1,
+ 1 => Self::node2,
+ _ => panic!("INTERCONNECTNODE index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<2> for INTERCONNECTNODE {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_INTERCONNECTNODE = BSet<INTERCONNECTNODE, 2>;
+//set_enum_declaration done
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum SOCKET {
+ #[default]
+ socket1 = 0,
+ socket2 = 1
+}
+
+impl SOCKET {
+ pub fn equal(&self, other: &SOCKET) -> bool { *self == *other }
+ pub fn unequal(&self, other: &SOCKET) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::socket1,
+ 1 => Self::socket2,
+ _ => panic!("SOCKET index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<2> for SOCKET {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_SOCKET = BSet<SOCKET, 2>;
+//set_enum_declaration done
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum SERVICE {
+ #[default]
+ service1 = 0,
+ service2 = 1
+}
+
+impl SERVICE {
+ pub fn equal(&self, other: &SERVICE) -> bool { *self == *other }
+ pub fn unequal(&self, other: &SERVICE) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::service1,
+ 1 => Self::service2,
+ _ => panic!("SERVICE index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<2> for SERVICE {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_SERVICE = BSet<SERVICE, 2>;
+//set_enum_declaration done
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum RESOURCEMANAGER {
+ #[default]
+ resource1 = 0,
+ resource2 = 1
+}
+
+impl RESOURCEMANAGER {
+ pub fn equal(&self, other: &RESOURCEMANAGER) -> bool { *self == *other }
+ pub fn unequal(&self, other: &RESOURCEMANAGER) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::resource1,
+ 1 => Self::resource2,
+ _ => panic!("RESOURCEMANAGER index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<2> for RESOURCEMANAGER {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_RESOURCEMANAGER = BSet<RESOURCEMANAGER, 2>;
+//set_enum_declaration done
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum SID {
+ #[default]
+ SID1 = 0,
+ SID2 = 1
+}
+
+impl SID {
+ pub fn equal(&self, other: &SID) -> bool { *self == *other }
+ pub fn unequal(&self, other: &SID) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::SID1,
+ 1 => Self::SID2,
+ _ => panic!("SID index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<2> for SID {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_SID = BSet<SID, 2>;
+//set_enum_declaration done
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum RM_ERROR_CODES {
+ #[default]
+ RM_SERVICE_FOUND = 0,
+ RM_SERVICE_NOT_FOUND = 1
+}
+
+impl RM_ERROR_CODES {
+ pub fn equal(&self, other: &RM_ERROR_CODES) -> bool { *self == *other }
+ pub fn unequal(&self, other: &RM_ERROR_CODES) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::RM_SERVICE_FOUND,
+ 1 => Self::RM_SERVICE_NOT_FOUND,
+ _ => panic!("RM_ERROR_CODES index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<2> for RM_ERROR_CODES {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_RM_ERROR_CODES = BSet<RM_ERROR_CODES, 2>;
+//set_enum_declaration done
+
+//set_enum_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum IN_ERROR_CODES {
+ #[default]
+ IN_REGISTRATION_OK = 0,
+ IN_REGISTRATION_FAILED = 1,
+ IN_DEREGISTRATION_OK = 2,
+ IN_DEREGISTRATION_FAILED = 3,
+ IN_NO_SOCKET_CONNECTION = 4,
+ IN_SOCKET_CONNECTION_OK = 5,
+ IN_NO_AVAILABLE_SERVICE = 6,
+ IN_SERVICE_AVAILABLE = 7,
+ IN_TARGET_SOCKET_GRANTED = 8,
+ IN_TARGET_SOCKET_NOT_GRANTED = 9
+}
+
+impl IN_ERROR_CODES {
+ pub fn equal(&self, other: &IN_ERROR_CODES) -> bool { *self == *other }
+ pub fn unequal(&self, other: &IN_ERROR_CODES) -> bool { *self != *other }
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::IN_REGISTRATION_OK,
+ 1 => Self::IN_REGISTRATION_FAILED,
+ 2 => Self::IN_DEREGISTRATION_OK,
+ 3 => Self::IN_DEREGISTRATION_FAILED,
+ 4 => Self::IN_NO_SOCKET_CONNECTION,
+ 5 => Self::IN_SOCKET_CONNECTION_OK,
+ 6 => Self::IN_NO_AVAILABLE_SERVICE,
+ 7 => Self::IN_SERVICE_AVAILABLE,
+ 8 => Self::IN_TARGET_SOCKET_GRANTED,
+ 9 => Self::IN_TARGET_SOCKET_NOT_GRANTED,
+ _ => panic!("IN_ERROR_CODES index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<10> for IN_ERROR_CODES {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+type set_IN_ERROR_CODES = BSet<IN_ERROR_CODES, 10>;
+//set_enum_declaration done
+
+//relation_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum SOCKET_X_INTERCONNECTNODE {
+ #[default]
+ socket1_node1 = 0,
+ socket1_node2 = 1,
+ socket2_node1 = 2,
+ socket2_node2 = 3
+}
+type rel_SOCKET_X_INTERCONNECTNODE = BRelation<SOCKET, { SOCKET::VARIANTS }, INTERCONNECTNODE, { INTERCONNECTNODE::VARIANTS }, 4>;
+//relation_declaration done
+
+//relation_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum RESOURCEMANAGER_X_SetSERVICE {
+ #[default]
+ resource1_SET__TES = 0,
+ resource1_SET_service1_TES = 1,
+ resource1_SET_service2_TES = 2,
+ resource1_SET_service1__service2_TES = 3,
+ resource2_SET__TES = 4,
+ resource2_SET_service1_TES = 5,
+ resource2_SET_service2_TES = 6,
+ resource2_SET_service1__service2_TES = 7
+}
+type rel_RESOURCEMANAGER_X_SetSERVICE = BRelation<RESOURCEMANAGER, { RESOURCEMANAGER::VARIANTS }, set_SERVICE, { set_SERVICE::VARIANTS }, 8>;
+//relation_declaration done
+
+//relation_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum INTERCONNECTNODE_X_SetRESOURCEMANAGER {
+ #[default]
+ node1_SET__TES = 0,
+ node1_SET_resource1_TES = 1,
+ node1_SET_resource2_TES = 2,
+ node1_SET_resource1__resource2_TES = 3,
+ node2_SET__TES = 4,
+ node2_SET_resource1_TES = 5,
+ node2_SET_resource2_TES = 6,
+ node2_SET_resource1__resource2_TES = 7
+}
+type rel_INTERCONNECTNODE_X_SetRESOURCEMANAGER = BRelation<INTERCONNECTNODE, { INTERCONNECTNODE::VARIANTS }, set_RESOURCEMANAGER, { set_RESOURCEMANAGER::VARIANTS }, 8>;
+//relation_declaration done
+
+//relation_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum SERVICE_X_SID {
+ #[default]
+ service1_SID1 = 0,
+ service1_SID2 = 1,
+ service2_SID1 = 2,
+ service2_SID2 = 3
+}
+type rel_SERVICE_X_SID = BRelation<SERVICE, { SERVICE::VARIANTS }, SID, { SID::VARIANTS }, 4>;
+//relation_declaration done
+
+
+
+
+
+
+
+
+
+//relation_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum SID_X_INTERCONNECTNODE {
+ #[default]
+ SID1_node1 = 0,
+ SID1_node2 = 1,
+ SID2_node1 = 2,
+ SID2_node2 = 3
+}
+type rel_SID_X_INTERCONNECTNODE = BRelation<SID, { SID::VARIANTS }, INTERCONNECTNODE, { INTERCONNECTNODE::VARIANTS }, 4>;
+//relation_declaration done
+
+//relation_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum SERVICE_X_INTERCONNECTNODE {
+ #[default]
+ service1_node1 = 0,
+ service1_node2 = 1,
+ service2_node1 = 2,
+ service2_node2 = 3
+}
+type rel_SERVICE_X_INTERCONNECTNODE = BRelation<SERVICE, { SERVICE::VARIANTS }, INTERCONNECTNODE, { INTERCONNECTNODE::VARIANTS }, 4>;
+//relation_declaration done
+
+//relation_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum SOCKET_X_SID {
+ #[default]
+ socket1_SID1 = 0,
+ socket1_SID2 = 1,
+ socket2_SID1 = 2,
+ socket2_SID2 = 3
+}
+type rel_SOCKET_X_SID = BRelation<SOCKET, { SOCKET::VARIANTS }, SID, { SID::VARIANTS }, 4>;
+//relation_declaration done
+
+
+
+//relation_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum SERVICE_X_SetSOCKET {
+ #[default]
+ service1_SET__TES = 0,
+ service1_SET_socket1_TES = 1,
+ service1_SET_socket2_TES = 2,
+ service1_SET_socket1__socket2_TES = 3,
+ service2_SET__TES = 4,
+ service2_SET_socket1_TES = 5,
+ service2_SET_socket2_TES = 6,
+ service2_SET_socket1__socket2_TES = 7
+}
+type rel_SERVICE_X_SetSOCKET = BRelation<SERVICE, { SERVICE::VARIANTS }, set_SOCKET, { set_SOCKET::VARIANTS }, 8>;
+//relation_declaration done
+
+
+
+//enum_set_declaration start
+#[derive(Default, Debug, Clone, Copy)]
+// each enum value corresponds to one BSet
+pub enum SetRESOURCEMANAGER {
+ #[default]
+ SET_SET__TES_TES = 0,
+ SET_SET_resource1_TES_TES = 1,
+ SET_SET_resource2_TES_TES = 2,
+ SET_SET_resource1__resource2_TES_TES = 3
+}
+type set_SetRESOURCEMANAGER = BSet<set_RESOURCEMANAGER, 4>;
+
+impl PowSetItem<4, 2> for RESOURCEMANAGER {
+ type SetRepr = SetRESOURCEMANAGER;
+ fn arr_to_idx(set: [bool; 2]) -> usize {
+ match set {
+ [false, false] => 0,
+ [true, false] => 1,
+ [false, true] => 2,
+ [true, true] => 3,
+ _ => panic!("Attempting to convert non-existing set to index!") // only happens if this is a const-set and code-generation missed a necessary value
+ }
+ }
+ fn idx_to_arr(idx: usize) -> [bool; 2] {
+ match idx {
+ 0 => [false, false],
+ 1 => [true, false],
+ 2 => [false, true],
+ 3 => [true, true],
+ _ => panic!("SetRESOURCEMANAGER index out of range! {:?}", idx)
+ }
+ }
+}
+impl SetRESOURCEMANAGER {
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::SET_SET__TES_TES,
+ 1 => Self::SET_SET_resource1_TES_TES,
+ 2 => Self::SET_SET_resource2_TES_TES,
+ 3 => Self::SET_SET_resource1__resource2_TES_TES,
+ _ => panic!("SetRESOURCEMANAGER index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<4> for SetRESOURCEMANAGER {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+//enum_set_declaration done
+
+//relation_declaration
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum SERVICE_X_BOOL {
+ #[default]
+ service1_BFALSE = 0,
+ service1_BTRUE = 1,
+ service2_BFALSE = 2,
+ service2_BTRUE = 3
+}
+type rel_SERVICE_X_BOOL = BRelation<SERVICE, { SERVICE::VARIANTS }, BBoolean, { BBoolean::VARIANTS }, 4>;
+//relation_declaration done
+
+//enum_set_declaration start
+#[derive(Default, Debug, Clone, Copy)]
+// each enum value corresponds to one BSet
+pub enum SetSERVICE {
+ #[default]
+ SET_SET__TES_TES = 0,
+ SET_SET_service1_TES_TES = 1,
+ SET_SET_service2_TES_TES = 2,
+ SET_SET_service1__service2_TES_TES = 3
+}
+type set_SetSERVICE = BSet<set_SERVICE, 4>;
+
+impl PowSetItem<4, 2> for SERVICE {
+ type SetRepr = SetSERVICE;
+ fn arr_to_idx(set: [bool; 2]) -> usize {
+ match set {
+ [false, false] => 0,
+ [true, false] => 1,
+ [false, true] => 2,
+ [true, true] => 3,
+ _ => panic!("Attempting to convert non-existing set to index!") // only happens if this is a const-set and code-generation missed a necessary value
+ }
+ }
+ fn idx_to_arr(idx: usize) -> [bool; 2] {
+ match idx {
+ 0 => [false, false],
+ 1 => [true, false],
+ 2 => [false, true],
+ 3 => [true, true],
+ _ => panic!("SetSERVICE index out of range! {:?}", idx)
+ }
+ }
+}
+impl SetSERVICE {
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::SET_SET__TES_TES,
+ 1 => Self::SET_SET_service1_TES_TES,
+ 2 => Self::SET_SET_service2_TES_TES,
+ 3 => Self::SET_SET_service1__service2_TES_TES,
+ _ => panic!("SetSERVICE index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<4> for SetSERVICE {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+//enum_set_declaration done
+
+
+
+//enum_set_declaration start
+#[derive(Default, Debug, Clone, Copy)]
+// each enum value corresponds to one BSet
+pub enum SetSOCKET {
+ #[default]
+ SET_SET__TES_TES = 0,
+ SET_SET_socket1_TES_TES = 1,
+ SET_SET_socket2_TES_TES = 2,
+ SET_SET_socket1__socket2_TES_TES = 3
+}
+type set_SetSOCKET = BSet<set_SOCKET, 4>;
+
+impl PowSetItem<4, 2> for SOCKET {
+ type SetRepr = SetSOCKET;
+ fn arr_to_idx(set: [bool; 2]) -> usize {
+ match set {
+ [false, false] => 0,
+ [true, false] => 1,
+ [false, true] => 2,
+ [true, true] => 3,
+ _ => panic!("Attempting to convert non-existing set to index!") // only happens if this is a const-set and code-generation missed a necessary value
+ }
+ }
+ fn idx_to_arr(idx: usize) -> [bool; 2] {
+ match idx {
+ 0 => [false, false],
+ 1 => [true, false],
+ 2 => [false, true],
+ 3 => [true, true],
+ _ => panic!("SetSOCKET index out of range! {:?}", idx)
+ }
+ }
+}
+impl SetSOCKET {
+ pub const fn to_idx(self) -> usize { self as usize }
+ pub fn from_idx(idx: usize) -> Self {
+ match idx {
+ 0 => Self::SET_SET__TES_TES,
+ 1 => Self::SET_SET_socket1_TES_TES,
+ 2 => Self::SET_SET_socket2_TES_TES,
+ 3 => Self::SET_SET_socket1__socket2_TES_TES,
+ _ => panic!("SetSOCKET index out of range! {:?}", idx)
+ }
+ }
+}
+
+impl SetItem<4> for SetSOCKET {
+ fn as_idx(&self) -> usize { self.to_idx() }
+ fn from_idx(idx: usize) -> Self { Self::from_idx(idx) }
+}
+
+//enum_set_declaration done
+
+#[derive(Derivative)]
+#[derivative(Clone, Default, Debug, Hash, PartialEq, Eq)]
+pub struct nota_v2 {
+ /*declarations*/interconnectNodes: set_INTERCONNECTNODE,
+ sockets: set_SOCKET,
+ services: set_SERVICE,
+ resourceManagers: set_RESOURCEMANAGER,
+ sids: set_SID,
+ rm_services: rel_RESOURCEMANAGER_X_SetSERVICE,
+ rm_sids: rel_SERVICE_X_SID,
+ in_localServices: rel_SID_X_INTERCONNECTNODE,
+ in_sockets: rel_SOCKET_X_INTERCONNECTNODE,
+ in_resourceManager: rel_INTERCONNECTNODE_X_SetRESOURCEMANAGER,
+ soc_to: rel_SOCKET_X_SID,
+ soc_from: rel_SOCKET_X_SID,
+ svc_serviceID: rel_SERVICE_X_SID,
+ svc_sockets: rel_SERVICE_X_SetSOCKET,
+ svc_ICNode: rel_SERVICE_X_INTERCONNECTNODE,
+ svc_registered: rel_SERVICE_X_BOOL,
+ /*sets*//*set_declaration*/_INTERCONNECTNODE: set_INTERCONNECTNODE,
+ /*set_declaration*/_SOCKET: set_SOCKET,
+ /*set_declaration*/_SERVICE: set_SERVICE,
+ /*set_declaration*/_RESOURCEMANAGER: set_RESOURCEMANAGER,
+ /*set_declaration*/_SID: set_SID,
+ /*set_declaration*/_RM_ERROR_CODES: set_RM_ERROR_CODES,
+ /*set_declaration*/_IN_ERROR_CODES: set_IN_ERROR_CODES,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_constructor_interconnectNode: Option<HashSet<INTERCONNECTNODE>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_constructor_resourceManager: Option<HashSet<RESOURCEMANAGER>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_constructor_service: Option<HashSet<(INTERCONNECTNODE, SERVICE)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_constructor_socket: Option<HashSet<(((INTERCONNECTNODE, SID), SID), SOCKET)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_rm_register: Option<HashSet<((RESOURCEMANAGER, SERVICE), INTERCONNECTNODE)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_rm_deregister: Option<HashSet<((RESOURCEMANAGER, SERVICE), INTERCONNECTNODE)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_rm_getSid: Option<HashSet<(RESOURCEMANAGER, SERVICE)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_rm_getSid_Not_Found: Option<HashSet<(RESOURCEMANAGER, SERVICE)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_in_announceResourceManager: Option<HashSet<(INTERCONNECTNODE, RESOURCEMANAGER)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_in_register_success: Option<HashSet<((INTERCONNECTNODE, SERVICE), SID)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_in_register_failed: Option<HashSet<(INTERCONNECTNODE, SERVICE)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_in_requestTargetSocket_Granted: Option<HashSet<(((((INTERCONNECTNODE, INTERCONNECTNODE), SOCKET), SID), SID), SOCKET)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_in_requestTargetSocket_NotGranted: Option<HashSet<((((INTERCONNECTNODE, INTERCONNECTNODE), SOCKET), SID), SID)>>,
+ #[derivative(Hash="ignore", PartialEq="ignore")]
+ _tr_cache_svc_register: Option<HashSet<SERVICE>>,}
+
+
+impl nota_v2 {
+
+ pub fn new() -> nota_v2 {
+ //values: ''
+ let mut m: nota_v2 = Default::default();
+ m.init();
+ return m;
+ }
+ fn init(&mut self) {
+ /*set_initializations*///set_initialization
+ self._INTERCONNECTNODE = bset![INTERCONNECTNODE, /*enum_call*/INTERCONNECTNODE::node1, /*enum_call*/INTERCONNECTNODE::node2];
+ //set_initialization
+ self._SOCKET = bset![SOCKET, /*enum_call*/SOCKET::socket1, /*enum_call*/SOCKET::socket2];
+ //set_initialization
+ self._SERVICE = bset![SERVICE, /*enum_call*/SERVICE::service1, /*enum_call*/SERVICE::service2];
+ //set_initialization
+ self._RESOURCEMANAGER = bset![RESOURCEMANAGER, /*enum_call*/RESOURCEMANAGER::resource1, /*enum_call*/RESOURCEMANAGER::resource2];
+ //set_initialization
+ self._SID = bset![SID, /*enum_call*/SID::SID1, /*enum_call*/SID::SID2];
+ //set_initialization
+ self._RM_ERROR_CODES = bset![RM_ERROR_CODES, /*enum_call*/RM_ERROR_CODES::RM_SERVICE_FOUND, /*enum_call*/RM_ERROR_CODES::RM_SERVICE_NOT_FOUND];
+ //set_initialization
+ self._IN_ERROR_CODES = bset![IN_ERROR_CODES, /*enum_call*/IN_ERROR_CODES::IN_REGISTRATION_OK, /*enum_call*/IN_ERROR_CODES::IN_REGISTRATION_FAILED, /*enum_call*/IN_ERROR_CODES::IN_DEREGISTRATION_OK, /*enum_call*/IN_ERROR_CODES::IN_DEREGISTRATION_FAILED, /*enum_call*/IN_ERROR_CODES::IN_NO_SOCKET_CONNECTION, /*enum_call*/IN_ERROR_CODES::IN_SOCKET_CONNECTION_OK, /*enum_call*/IN_ERROR_CODES::IN_NO_AVAILABLE_SERVICE, /*enum_call*/IN_ERROR_CODES::IN_SERVICE_AVAILABLE, /*enum_call*/IN_ERROR_CODES::IN_TARGET_SOCKET_GRANTED, /*enum_call*/IN_ERROR_CODES::IN_TARGET_SOCKET_NOT_GRANTED];
+ /*properties*/
+ /*body*/self.interconnectNodes = bset![INTERCONNECTNODE].clone().clone();
+ self.sockets = bset![SOCKET].clone().clone();
+ self.services = bset![SERVICE].clone().clone();
+ self.resourceManagers = bset![RESOURCEMANAGER].clone().clone();
+ self.sids = bset![SID].clone().clone();
+ self.rm_services = brel![rel_RESOURCEMANAGER_X_SetSERVICE].clone().clone();
+ self.rm_sids = brel![rel_SERVICE_X_SID].clone().clone();
+ self.in_localServices = brel![rel_SID_X_INTERCONNECTNODE].clone().clone();
+ self.in_sockets = brel![rel_SOCKET_X_INTERCONNECTNODE].clone().clone();
+ self.in_resourceManager = brel![rel_INTERCONNECTNODE_X_SetRESOURCEMANAGER].clone().clone();
+ self.soc_to = brel![rel_SOCKET_X_SID].clone().clone();
+ self.soc_from = brel![rel_SOCKET_X_SID].clone().clone();
+ self.svc_serviceID = brel![rel_SERVICE_X_SID].clone().clone();
+ self.svc_sockets = brel![rel_SERVICE_X_SetSOCKET].clone().clone();
+ self.svc_ICNode = brel![rel_SERVICE_X_INTERCONNECTNODE].clone().clone();
+ self.svc_registered = brel![rel_SERVICE_X_BOOL].clone().clone();
+ /*includesInitialization*/
+ }
+
+ pub fn get_interconnectNodes(&self) -> set_INTERCONNECTNODE {
+ return self.interconnectNodes.clone();
+ }
+
+ pub fn get_sockets(&self) -> set_SOCKET {
+ return self.sockets.clone();
+ }
+
+ pub fn get_services(&self) -> set_SERVICE {
+ return self.services.clone();
+ }
+
+ pub fn get_resourceManagers(&self) -> set_RESOURCEMANAGER {
+ return self.resourceManagers.clone();
+ }
+
+ pub fn get_sids(&self) -> set_SID {
+ return self.sids.clone();
+ }
+
+ pub fn get_rm_services(&self) -> rel_RESOURCEMANAGER_X_SetSERVICE {
+ return self.rm_services.clone();
+ }
+
+ pub fn get_rm_sids(&self) -> rel_SERVICE_X_SID {
+ return self.rm_sids.clone();
+ }
+
+ pub fn get_in_localServices(&self) -> rel_SID_X_INTERCONNECTNODE {
+ return self.in_localServices.clone();
+ }
+
+ pub fn get_in_sockets(&self) -> rel_SOCKET_X_INTERCONNECTNODE {
+ return self.in_sockets.clone();
+ }
+
+ pub fn get_in_resourceManager(&self) -> rel_INTERCONNECTNODE_X_SetRESOURCEMANAGER {
+ return self.in_resourceManager.clone();
+ }
+
+ pub fn get_soc_to(&self) -> rel_SOCKET_X_SID {
+ return self.soc_to.clone();
+ }
+
+ pub fn get_soc_from(&self) -> rel_SOCKET_X_SID {
+ return self.soc_from.clone();
+ }
+
+ pub fn get_svc_serviceID(&self) -> rel_SERVICE_X_SID {
+ return self.svc_serviceID.clone();
+ }
+
+ pub fn get_svc_sockets(&self) -> rel_SERVICE_X_SetSOCKET {
+ return self.svc_sockets.clone();
+ }
+
+ pub fn get_svc_ICNode(&self) -> rel_SERVICE_X_INTERCONNECTNODE {
+ return self.svc_ICNode.clone();
+ }
+
+ pub fn get_svc_registered(&self) -> rel_SERVICE_X_BOOL {
+ return self.svc_registered.clone();
+ }
+
+ pub fn get__INTERCONNECTNODE(&self) -> set_INTERCONNECTNODE {
+ return self._INTERCONNECTNODE.clone();
+ }
+
+ pub fn get__SOCKET(&self) -> set_SOCKET {
+ return self._SOCKET.clone();
+ }
+
+ pub fn get__SERVICE(&self) -> set_SERVICE {
+ return self._SERVICE.clone();
+ }
+
+ pub fn get__RESOURCEMANAGER(&self) -> set_RESOURCEMANAGER {
+ return self._RESOURCEMANAGER.clone();
+ }
+
+ pub fn get__SID(&self) -> set_SID {
+ return self._SID.clone();
+ }
+
+ pub fn get__RM_ERROR_CODES(&self) -> set_RM_ERROR_CODES {
+ return self._RM_ERROR_CODES.clone();
+ }
+
+ pub fn get__IN_ERROR_CODES(&self) -> set_IN_ERROR_CODES {
+ return self._IN_ERROR_CODES.clone();
+ }
+
+ pub fn constructor_interconnectNode(&mut self, mut newic: INTERCONNECTNODE) -> INTERCONNECTNODE {
+ let mut oid: Option<INTERCONNECTNODE> = Option::None;
+ //select
+ if self._INTERCONNECTNODE.difference(&self.interconnectNodes).elementOf(&newic) {
+ let mut _ld_interconnectNodes = self.interconnectNodes.clone();
+ self.interconnectNodes = _ld_interconnectNodes.union(&bset![INTERCONNECTNODE, newic]).clone().clone();
+ self.in_resourceManager = self.in_resourceManager._override_single(newic, bset![RESOURCEMANAGER]);
+ oid = Option::Some(newic);
+ } else {
+ panic!("ERROR: called SELECT-function with incompatible parameters!");
+ }
+ return oid.unwrap();
+ }
+
+ pub fn constructor_resourceManager(&mut self, mut newrm: RESOURCEMANAGER) -> RESOURCEMANAGER {
+ let mut oid: Option<RESOURCEMANAGER> = Option::None;
+ //pre_assert
+ let mut _ld_resourceManagers = self.resourceManagers.clone();
+ self.resourceManagers = _ld_resourceManagers.union(&bset![RESOURCEMANAGER, newrm]).clone().clone();
+ self.rm_services = self.rm_services._override_single(newrm, bset![SERVICE]);
+ oid = Option::Some(newrm);
+
+ return oid.unwrap();
+ }
+
+ pub fn constructor_service(&mut self, mut ii: INTERCONNECTNODE, mut newsvc: SERVICE) -> SERVICE {
+ let mut oid: Option<SERVICE> = Option::None;
+ //pre_assert
+ let mut _ld_services = self.services.clone();
+ self.services = _ld_services.union(&bset![SERVICE, newsvc]).clone().clone();
+ self.svc_registered = self.svc_registered._override_single(newsvc, false);
+ self.svc_sockets = self.svc_sockets._override_single(newsvc, bset![SOCKET]);
+ self.svc_ICNode = self.svc_ICNode._override_single(newsvc, ii);
+ self.svc_serviceID = brel![rel_SERVICE_X_SID].clone().clone();
+ oid = Option::Some(newsvc);
+
+ return oid.unwrap();
+ }
+
+ pub fn constructor_socket(&mut self, mut ii: INTERCONNECTNODE, mut srcsid: SID, mut targsid: SID, mut newsoc: SOCKET) -> SOCKET {
+ let mut oid: Option<SOCKET> = Option::None;
+ //pre_assert
+ let mut _ld_sockets = self.sockets.clone();
+ self.sockets = _ld_sockets.union(&bset![SOCKET, newsoc]).clone().clone();
+ oid = Option::Some(newsoc);
+ self.in_sockets = self.in_sockets._override_single(newsoc, ii);
+ self.soc_to = self.soc_to._override_single(newsoc, srcsid);
+ self.soc_from = self.soc_from._override_single(newsoc, targsid);
+
+ return oid.unwrap();
+ }
+
+ pub fn rm_register(&mut self, mut _self: RESOURCEMANAGER, mut ss: SERVICE, mut ii: INTERCONNECTNODE) -> () {
+ //pre_assert
+
+ }
+
+ pub fn rm_deregister(&mut self, mut _self: RESOURCEMANAGER, mut ss: SERVICE, mut ii: INTERCONNECTNODE) -> () {
+ //pre_assert
+
+ }
+
+ pub fn rm_getSid(&mut self, mut _self: RESOURCEMANAGER, mut ss: SERVICE) -> _Struct1 {
+ let mut sid: Option<set_SID> = Option::None;
+ let mut err: Option<RM_ERROR_CODES> = Option::None;
+ //pre_assert
+ err = Option::Some(/*enum_call*/RM_ERROR_CODES::RM_SERVICE_FOUND);
+ sid = Option::Some(bset![SID, self.rm_sids.functionCall(&ss)].clone()).clone();
+
+ return /*record*/_Struct1::new(sid.unwrap(), err.unwrap());
+ }
+
+ pub fn rm_getSid_Not_Found(&mut self, mut _self: RESOURCEMANAGER, mut ss: SERVICE) -> _Struct1 {
+ let mut sid: Option<set_SID> = Option::None;
+ let mut err: Option<RM_ERROR_CODES> = Option::None;
+ //pre_assert
+ sid = Option::Some(self._SID.difference(&self._SID).clone()).clone();
+ err = Option::Some(/*enum_call*/RM_ERROR_CODES::RM_SERVICE_NOT_FOUND);
+
+ return /*record*/_Struct1::new(sid.unwrap(), err.unwrap());
+ }
+
+ pub fn in_announceResourceManager(&mut self, mut _self: INTERCONNECTNODE, mut rm: RESOURCEMANAGER) -> () {
+ //pre_assert
+ self.in_resourceManager = self.in_resourceManager._override_single(_self, self.in_resourceManager.functionCall(&_self).union(&bset![RESOURCEMANAGER, rm]));
+
+ }
+
+ pub fn in_register_success(&mut self, mut _self: INTERCONNECTNODE, mut ss: SERVICE, mut si: SID) -> _Struct3 {
+ let mut sid: Option<set_SID> = Option::None;
+ let mut err: Option<IN_ERROR_CODES> = Option::None;
+ //pre_assert
+ let mut _ld_sids = self.sids.clone();
+
+ let mut _ld_in_localServices = self.in_localServices.clone();
+ self.sids = _ld_sids.union(&bset![SID, si]).clone().clone();
+ self.in_localServices = _ld_in_localServices.union(&brel![rel_SID_X_INTERCONNECTNODE, (si.clone(), _self.clone())]).clone().clone();
+ err = Option::Some(/*enum_call*/IN_ERROR_CODES::IN_REGISTRATION_OK);
+ sid = Option::Some(bset![SID, si].clone()).clone();
+
+ return /*record*/_Struct3::new(sid.unwrap(), err.unwrap());
+ }
+
+ pub fn in_register_failed(&mut self, mut _self: INTERCONNECTNODE, mut ss: SERVICE) -> _Struct3 {
+ let mut sid: Option<set_SID> = Option::None;
+ let mut err: Option<IN_ERROR_CODES> = Option::None;
+ //pre_assert
+ sid = Option::Some(self._SID.difference(&self._SID).clone()).clone();
+ err = Option::Some(/*enum_call*/IN_ERROR_CODES::IN_REGISTRATION_FAILED);
+
+ return /*record*/_Struct3::new(sid.unwrap(), err.unwrap());
+ }
+
+ pub fn in_requestTargetSocket_Granted(&mut self, mut _self: INTERCONNECTNODE, mut ii: INTERCONNECTNODE, mut srcsoc: SOCKET, mut srcsid: SID, mut targsid: SID, mut newsoc: SOCKET) -> _Struct5 {
+ let mut soc: Option<set_SOCKET> = Option::None;
+ let mut err: Option<IN_ERROR_CODES> = Option::None;
+ //pre_assert
+ let mut _ld_sockets = self.sockets.clone();
+ let mut _ld_in_sockets = self.in_sockets.clone();
+ self.sockets = _ld_sockets.union(&bset![SOCKET, newsoc]).clone().clone();
+ soc = Option::Some(bset![SOCKET, newsoc].clone()).clone();
+ err = Option::Some(/*enum_call*/IN_ERROR_CODES::IN_TARGET_SOCKET_GRANTED);
+ self.in_sockets = _ld_in_sockets.union(&brel![rel_SOCKET_X_INTERCONNECTNODE, (newsoc.clone(), _self.clone())]).clone().clone();
+ self.soc_to = self.soc_to._override_single(newsoc, srcsid);
+ self.soc_from = self.soc_from._override_single(newsoc, targsid);
+
+ return /*record*/_Struct5::new(soc.unwrap(), err.unwrap());
+ }
+
+ pub fn in_requestTargetSocket_NotGranted(&mut self, mut _self: INTERCONNECTNODE, mut ii: INTERCONNECTNODE, mut srcsoc: SOCKET, mut srcsid: SID, mut targsid: SID) -> _Struct5 {
+ let mut soc: Option<set_SOCKET> = Option::None;
+ let mut err: Option<IN_ERROR_CODES> = Option::None;
+ //pre_assert
+ soc = Option::Some(self._SOCKET.difference(&self._SOCKET).clone()).clone();
+ err = Option::Some(/*enum_call*/IN_ERROR_CODES::IN_TARGET_SOCKET_NOT_GRANTED);
+
+ return /*record*/_Struct5::new(soc.unwrap(), err.unwrap());
+ }
+
+ pub fn svc_register(&mut self, mut _self: SERVICE) -> () {
+ //pre_assert
+ self.svc_registered = self.svc_registered._override_single(_self, true);
+
+ }
+
+ pub fn _tr_constructor_interconnectNode(&mut self, is_caching: bool) -> HashSet<INTERCONNECTNODE> {
+ //transition
+ if !is_caching || self._tr_cache_constructor_interconnectNode.is_none() {
+ let mut _ic_set_0: HashSet<INTERCONNECTNODE> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_newic_1 in self._INTERCONNECTNODE.difference(&self.interconnectNodes).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ _ic_set_0.insert(_ic_newic_1);
+
+ }
+ self._tr_cache_constructor_interconnectNode = Option::Some(_ic_set_0.clone());
+ return _ic_set_0;
+ } else {
+ return self._tr_cache_constructor_interconnectNode.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_constructor_resourceManager(&mut self, is_caching: bool) -> HashSet<RESOURCEMANAGER> {
+ //transition
+ if !is_caching || self._tr_cache_constructor_resourceManager.is_none() {
+ let mut _ic_set_1: HashSet<RESOURCEMANAGER> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_newrm_1 in self._RESOURCEMANAGER.difference(&self.resourceManagers).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if (self.rm_services.domain().notElementOf(&_ic_newrm_1) && self.resourceManagers.equal(&bset![RESOURCEMANAGER])) {
+ _ic_set_1.insert(_ic_newrm_1);
+ }
+
+ }
+ self._tr_cache_constructor_resourceManager = Option::Some(_ic_set_1.clone());
+ return _ic_set_1;
+ } else {
+ return self._tr_cache_constructor_resourceManager.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_constructor_service(&mut self, is_caching: bool) -> HashSet<(INTERCONNECTNODE, SERVICE)> {
+ //transition
+ if !is_caching || self._tr_cache_constructor_service.is_none() {
+ let mut _ic_set_2: HashSet<(INTERCONNECTNODE, SERVICE)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_ii_1 in self.interconnectNodes.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_newsvc_1 in self._SERVICE.difference(&self.services).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ _ic_set_2.insert((_ic_ii_1.clone(), _ic_newsvc_1.clone()));
+
+ }
+ }
+ self._tr_cache_constructor_service = Option::Some(_ic_set_2.clone());
+ return _ic_set_2;
+ } else {
+ return self._tr_cache_constructor_service.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_constructor_socket(&mut self, is_caching: bool) -> HashSet<(((INTERCONNECTNODE, SID), SID), SOCKET)> {
+ //transition
+ if !is_caching || self._tr_cache_constructor_socket.is_none() {
+ let mut _ic_set_3: HashSet<(((INTERCONNECTNODE, SID), SID), SOCKET)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_ii_1 in self.interconnectNodes.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_srcsid_1 in self.sids.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_targsid_1 in self.sids.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_newsoc_1 in self._SOCKET.difference(&self.sockets).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ _ic_set_3.insert((((_ic_ii_1.clone(), _ic_srcsid_1.clone()).clone(), _ic_targsid_1.clone()).clone(), _ic_newsoc_1.clone()));
+
+ }
+ }
+ }
+ }
+ self._tr_cache_constructor_socket = Option::Some(_ic_set_3.clone());
+ return _ic_set_3;
+ } else {
+ return self._tr_cache_constructor_socket.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_rm_register(&mut self, is_caching: bool) -> HashSet<((RESOURCEMANAGER, SERVICE), INTERCONNECTNODE)> {
+ //transition
+ if !is_caching || self._tr_cache_rm_register.is_none() {
+ let mut _ic_set_4: HashSet<((RESOURCEMANAGER, SERVICE), INTERCONNECTNODE)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_self_1 in self.resourceManagers.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_ss_1 in self.services.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_ii_1 in self.interconnectNodes.clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ _ic_set_4.insert(((_ic_self_1.clone(), _ic_ss_1.clone()).clone(), _ic_ii_1.clone()));
+
+ }
+ }
+ }
+ self._tr_cache_rm_register = Option::Some(_ic_set_4.clone());
+ return _ic_set_4;
+ } else {
+ return self._tr_cache_rm_register.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_rm_deregister(&mut self, is_caching: bool) -> HashSet<((RESOURCEMANAGER, SERVICE), INTERCONNECTNODE)> {
+ //transition
+ if !is_caching || self._tr_cache_rm_deregister.is_none() {
+ let mut _ic_set_5: HashSet<((RESOURCEMANAGER, SERVICE), INTERCONNECTNODE)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_self_1 in self.resourceManagers.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_ss_1 in self.services.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_ii_1 in self.interconnectNodes.clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ _ic_set_5.insert(((_ic_self_1.clone(), _ic_ss_1.clone()).clone(), _ic_ii_1.clone()));
+
+ }
+ }
+ }
+ self._tr_cache_rm_deregister = Option::Some(_ic_set_5.clone());
+ return _ic_set_5;
+ } else {
+ return self._tr_cache_rm_deregister.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_rm_getSid(&mut self, is_caching: bool) -> HashSet<(RESOURCEMANAGER, SERVICE)> {
+ //transition
+ if !is_caching || self._tr_cache_rm_getSid.is_none() {
+ let mut _ic_set_6: HashSet<(RESOURCEMANAGER, SERVICE)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_self_1 in self.resourceManagers.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_ss_1 in self.services.clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if self.rm_sids.domain().elementOf(&_ic_ss_1) {
+ _ic_set_6.insert((_ic_self_1.clone(), _ic_ss_1.clone()));
+ }
+
+ }
+ }
+ self._tr_cache_rm_getSid = Option::Some(_ic_set_6.clone());
+ return _ic_set_6;
+ } else {
+ return self._tr_cache_rm_getSid.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_rm_getSid_Not_Found(&mut self, is_caching: bool) -> HashSet<(RESOURCEMANAGER, SERVICE)> {
+ //transition
+ if !is_caching || self._tr_cache_rm_getSid_Not_Found.is_none() {
+ let mut _ic_set_7: HashSet<(RESOURCEMANAGER, SERVICE)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_self_1 in self.resourceManagers.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_ss_1 in self.services.clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ _ic_set_7.insert((_ic_self_1.clone(), _ic_ss_1.clone()));
+
+ }
+ }
+ self._tr_cache_rm_getSid_Not_Found = Option::Some(_ic_set_7.clone());
+ return _ic_set_7;
+ } else {
+ return self._tr_cache_rm_getSid_Not_Found.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_in_announceResourceManager(&mut self, is_caching: bool) -> HashSet<(INTERCONNECTNODE, RESOURCEMANAGER)> {
+ //transition
+ if !is_caching || self._tr_cache_in_announceResourceManager.is_none() {
+ let mut _ic_set_8: HashSet<(INTERCONNECTNODE, RESOURCEMANAGER)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_self_1 in self.interconnectNodes.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_rm_1 in self.resourceManagers.clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if self.in_resourceManager.functionCall(&_ic_self_1).equal(&bset![RESOURCEMANAGER]) {
+ _ic_set_8.insert((_ic_self_1.clone(), _ic_rm_1.clone()));
+ }
+
+ }
+ }
+ self._tr_cache_in_announceResourceManager = Option::Some(_ic_set_8.clone());
+ return _ic_set_8;
+ } else {
+ return self._tr_cache_in_announceResourceManager.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_in_register_success(&mut self, is_caching: bool) -> HashSet<((INTERCONNECTNODE, SERVICE), SID)> {
+ //transition
+ if !is_caching || self._tr_cache_in_register_success.is_none() {
+ let mut _ic_set_9: HashSet<((INTERCONNECTNODE, SERVICE), SID)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_self_1 in self.interconnectNodes.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_ss_1 in self.services.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_si_1 in self._SID.difference(&self.sids).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if self.in_localServices.domain().elementOf(&_ic_si_1).not() {
+ _ic_set_9.insert(((_ic_self_1.clone(), _ic_ss_1.clone()).clone(), _ic_si_1.clone()));
+ }
+
+ }
+ }
+ }
+ self._tr_cache_in_register_success = Option::Some(_ic_set_9.clone());
+ return _ic_set_9;
+ } else {
+ return self._tr_cache_in_register_success.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_in_register_failed(&mut self, is_caching: bool) -> HashSet<(INTERCONNECTNODE, SERVICE)> {
+ //transition
+ if !is_caching || self._tr_cache_in_register_failed.is_none() {
+ let mut _ic_set_10: HashSet<(INTERCONNECTNODE, SERVICE)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_self_1 in self.interconnectNodes.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_ss_1 in self.services.clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ _ic_set_10.insert((_ic_self_1.clone(), _ic_ss_1.clone()));
+
+ }
+ }
+ self._tr_cache_in_register_failed = Option::Some(_ic_set_10.clone());
+ return _ic_set_10;
+ } else {
+ return self._tr_cache_in_register_failed.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_in_requestTargetSocket_Granted(&mut self, is_caching: bool) -> HashSet<(((((INTERCONNECTNODE, INTERCONNECTNODE), SOCKET), SID), SID), SOCKET)> {
+ //transition
+ if !is_caching || self._tr_cache_in_requestTargetSocket_Granted.is_none() {
+ let mut _ic_set_11: HashSet<(((((INTERCONNECTNODE, INTERCONNECTNODE), SOCKET), SID), SID), SOCKET)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_self_1 in self.interconnectNodes.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_ii_1 in self.interconnectNodes.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_srcsoc_1 in self.sockets.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_srcsid_1 in self.sids.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_targsid_1 in self.sids.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_newsoc_1 in self._SOCKET.difference(&self.sockets).clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if (_ic_self_1.unequal(&_ic_ii_1) && self.in_sockets.functionCall(&_ic_srcsoc_1).equal(&_ic_ii_1)) {
+ _ic_set_11.insert((((((_ic_self_1.clone(), _ic_ii_1.clone()).clone(), _ic_srcsoc_1.clone()).clone(), _ic_srcsid_1.clone()).clone(), _ic_targsid_1.clone()).clone(), _ic_newsoc_1.clone()));
+ }
+
+ }
+ }
+ }
+ }
+ }
+ }
+ self._tr_cache_in_requestTargetSocket_Granted = Option::Some(_ic_set_11.clone());
+ return _ic_set_11;
+ } else {
+ return self._tr_cache_in_requestTargetSocket_Granted.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_in_requestTargetSocket_NotGranted(&mut self, is_caching: bool) -> HashSet<((((INTERCONNECTNODE, INTERCONNECTNODE), SOCKET), SID), SID)> {
+ //transition
+ if !is_caching || self._tr_cache_in_requestTargetSocket_NotGranted.is_none() {
+ let mut _ic_set_12: HashSet<((((INTERCONNECTNODE, INTERCONNECTNODE), SOCKET), SID), SID)> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_self_1 in self.interconnectNodes.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_ii_1 in self.interconnectNodes.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_srcsoc_1 in self.sockets.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_srcsid_1 in self.sids.clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_targsid_1 in self.sids.clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if (_ic_self_1.unequal(&_ic_ii_1) && self.in_sockets.functionCall(&_ic_srcsoc_1).equal(&_ic_ii_1)) {
+ _ic_set_12.insert(((((_ic_self_1.clone(), _ic_ii_1.clone()).clone(), _ic_srcsoc_1.clone()).clone(), _ic_srcsid_1.clone()).clone(), _ic_targsid_1.clone()));
+ }
+
+ }
+ }
+ }
+ }
+ }
+ self._tr_cache_in_requestTargetSocket_NotGranted = Option::Some(_ic_set_12.clone());
+ return _ic_set_12;
+ } else {
+ return self._tr_cache_in_requestTargetSocket_NotGranted.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _tr_svc_register(&mut self, is_caching: bool) -> HashSet<SERVICE> {
+ //transition
+ if !is_caching || self._tr_cache_svc_register.is_none() {
+ let mut _ic_set_13: HashSet<SERVICE> = HashSet::new();
+ //transition, parameters, no condidtion
+ //iteration_construct_enumeration
+ for _ic_self_1 in self.services.clone().iter() {
+ //parameter_combination_predicate TODO: FASTER
+ if self.svc_registered.functionCall(&_ic_self_1).equal(&false) {
+ _ic_set_13.insert(_ic_self_1);
+ }
+
+ }
+ self._tr_cache_svc_register = Option::Some(_ic_set_13.clone());
+ return _ic_set_13;
+ } else {
+ return self._tr_cache_svc_register.as_ref().unwrap().clone();
+ }
+ }
+
+ pub fn _check_inv_1(&self) -> bool {
+ //invariant
+ return self.interconnectNodes.subset(&self._INTERCONNECTNODE);
+ }
+
+ pub fn _check_inv_2(&self) -> bool {
+ //invariant
+ return self.sockets.subset(&self._SOCKET);
+ }
+
+ pub fn _check_inv_3(&self) -> bool {
+ //invariant
+ return self.services.subset(&self._SERVICE);
+ }
+
+ pub fn _check_inv_4(&self) -> bool {
+ //invariant
+ return self.resourceManagers.subset(&self._RESOURCEMANAGER);
+ }
+
+ pub fn _check_inv_5(&self) -> bool {
+ //invariant
+ return self.sids.subset(&self._SID);
+ }
+
+ pub fn _check_inv_6(&self) -> bool {
+ //invariant
+ return self.resourceManagers.check_domain_of(&self.rm_services).and(&self.services.pow().check_range_of(&self.rm_services)).and(&self.rm_services.isFunction()).and(&self.resourceManagers.check_total_of(&self.rm_services));
+ }
+
+ pub fn _check_inv_7(&self) -> bool {
+ //invariant
+ //quantified_predicate
+ let mut _ic_boolean_14 = true;
+ //iteration_construct_enumeration
+ for _ic_a1_1 in self.rm_services.domain().clone().iter() {
+ //iteration_construct_enumeration
+ for _ic_a2_1 in self.rm_services.domain().clone().iter() {
+ if !_ic_a1_1.unequal(&_ic_a2_1).implies(|| self.rm_services.functionCall(&_ic_a1_1).intersect(&self.rm_services.functionCall(&_ic_a2_1)).equal(&bset![SERVICE])) {
+ _ic_boolean_14 = false;
+ break;
+ }
+
+ }
+ }
+
+ return _ic_boolean_14;
+ }
+
+ pub fn _check_inv_8(&self) -> bool {
+ //invariant
+ return self.services.check_domain_of(&self.rm_sids).and(&self.sids.check_range_of(&self.rm_sids)).and(&self.rm_sids.isFunction()).and(&self.services.check_partial_of(&self.rm_sids)).and(&self.rm_sids.isInjection());
+ }
+
+ pub fn _check_inv_9(&self) -> bool {
+ //invariant
+ return self.sids.check_domain_of(&self.in_localServices).and(&self.interconnectNodes.check_range_of(&self.in_localServices)).and(&self.in_localServices.isFunction()).and(&self.sids.check_total_of(&self.in_localServices));
+ }
+
+ pub fn _check_inv_10(&self) -> bool {
+ //invariant
+ return self.sockets.check_domain_of(&self.in_sockets).and(&self.interconnectNodes.check_range_of(&self.in_sockets)).and(&self.in_sockets.isFunction()).and(&self.sockets.check_total_of(&self.in_sockets));
+ }
+
+ pub fn _check_inv_11(&self) -> bool {
+ //invariant
+ return self.interconnectNodes.check_domain_of(&self.in_resourceManager).and(&self.resourceManagers.pow().check_range_of(&self.in_resourceManager)).and(&self.in_resourceManager.isFunction()).and(&self.interconnectNodes.check_total_of(&self.in_resourceManager));
+ }
+
+ pub fn _check_inv_12(&self) -> bool {
+ //invariant
+ return self.sockets.check_domain_of(&self.soc_to).and(&self.sids.check_range_of(&self.soc_to)).and(&self.soc_to.isFunction()).and(&self.sockets.check_total_of(&self.soc_to));
+ }
+
+ pub fn _check_inv_13(&self) -> bool {
+ //invariant
+ return self.sockets.check_domain_of(&self.soc_from).and(&self.sids.check_range_of(&self.soc_from)).and(&self.soc_from.isFunction()).and(&self.sockets.check_total_of(&self.soc_from));
+ }
+
+ pub fn _check_inv_14(&self) -> bool {
+ //invariant
+ return self.services.check_domain_of(&self.svc_serviceID).and(&self.sids.check_range_of(&self.svc_serviceID)).and(&self.svc_serviceID.isFunction()).and(&self.services.check_partial_of(&self.svc_serviceID));
+ }
+
+ pub fn _check_inv_15(&self) -> bool {
+ //invariant
+ return self.services.check_domain_of(&self.svc_sockets).and(&self.sockets.pow().check_range_of(&self.svc_sockets)).and(&self.svc_sockets.isFunction()).and(&self.services.check_total_of(&self.svc_sockets));
+ }
+
+ pub fn _check_inv_16(&self) -> bool {
+ //invariant
+ return self.services.check_domain_of(&self.svc_ICNode).and(&self.interconnectNodes.check_range_of(&self.svc_ICNode)).and(&self.svc_ICNode.isFunction()).and(&self.services.check_total_of(&self.svc_ICNode));
+ }
+
+ pub fn _check_inv_17(&self) -> bool {
+ //invariant
+ return self.services.check_domain_of(&self.svc_registered).and(&BOOL.check_range_of(&self.svc_registered)).and(&self.svc_registered.isFunction()).and(&self.services.check_total_of(&self.svc_registered));
+ }
+
+ pub fn _check_inv_18(&self) -> bool {
+ //invariant
+ return self.resourceManagers.equal(&bset![RESOURCEMANAGER]).not().implies(|| self.resourceManagers.card().equal(&1));
+ }
+
+ fn invalidate_caches(&mut self, to_invalidate: Vec<&'static str>) {
+ //calling the given functions without caching will recalculate them and cache them afterwards
+ for trans in to_invalidate {
+ match trans {
+ "_tr_constructor_interconnectNode" => {self._tr_constructor_interconnectNode(false);},
+ "_tr_constructor_resourceManager" => {self._tr_constructor_resourceManager(false);},
+ "_tr_constructor_service" => {self._tr_constructor_service(false);},
+ "_tr_constructor_socket" => {self._tr_constructor_socket(false);},
+ "_tr_rm_register" => {self._tr_rm_register(false);},
+ "_tr_rm_deregister" => {self._tr_rm_deregister(false);},
+ "_tr_rm_getSid" => {self._tr_rm_getSid(false);},
+ "_tr_rm_getSid_Not_Found" => {self._tr_rm_getSid_Not_Found(false);},
+ "_tr_in_announceResourceManager" => {self._tr_in_announceResourceManager(false);},
+ "_tr_in_register_success" => {self._tr_in_register_success(false);},
+ "_tr_in_register_failed" => {self._tr_in_register_failed(false);},
+ "_tr_in_requestTargetSocket_Granted" => {self._tr_in_requestTargetSocket_Granted(false);},
+ "_tr_in_requestTargetSocket_NotGranted" => {self._tr_in_requestTargetSocket_NotGranted(false);},
+ "_tr_svc_register" => {self._tr_svc_register(false);},
+ _ => {},
+ }
+ }
+ }
+
+ //model_check_next_states
+ fn generateNextStates(state: &mut nota_v2,
+ isCaching: bool,
+ transitions: Arc<AtomicU64>) -> HashSet<(nota_v2, &'static str)> {
+ let mut result = HashSet::<(nota_v2, &'static str)>::new();
+ let mut evaluated_transitions: u64 = 0;
+ //model_check_transition
+ let mut _trid_1 = state._tr_constructor_interconnectNode(isCaching);
+ for param in _trid_1.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.constructor_interconnectNode(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("constructor_interconnectNode")); }
+ result.insert((copiedState, "constructor_interconnectNode"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_2 = state._tr_constructor_resourceManager(isCaching);
+ for param in _trid_2.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.constructor_resourceManager(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("constructor_resourceManager")); }
+ result.insert((copiedState, "constructor_resourceManager"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_3 = state._tr_constructor_service(isCaching);
+ for param in _trid_3.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.constructor_service(_tmp_2, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("constructor_service")); }
+ result.insert((copiedState, "constructor_service"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_4 = state._tr_constructor_socket(isCaching);
+ for param in _trid_4.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+ //model_check_transition_param_assignment
+ let mut _tmp_3 = _tmp_2.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_4 = _tmp_2.projection1();
+ //model_check_transition_param_assignment
+ let mut _tmp_5 = _tmp_4.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_6 = _tmp_4.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.constructor_socket(_tmp_6, _tmp_5, _tmp_3, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("constructor_socket")); }
+ result.insert((copiedState, "constructor_socket"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_5 = state._tr_rm_register(isCaching);
+ for param in _trid_5.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+ //model_check_transition_param_assignment
+ let mut _tmp_3 = _tmp_2.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_4 = _tmp_2.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.rm_register(_tmp_4, _tmp_3, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("rm_register")); }
+ result.insert((copiedState, "rm_register"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_6 = state._tr_rm_deregister(isCaching);
+ for param in _trid_6.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+ //model_check_transition_param_assignment
+ let mut _tmp_3 = _tmp_2.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_4 = _tmp_2.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.rm_deregister(_tmp_4, _tmp_3, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("rm_deregister")); }
+ result.insert((copiedState, "rm_deregister"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_7 = state._tr_rm_getSid(isCaching);
+ for param in _trid_7.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.rm_getSid(_tmp_2, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("rm_getSid")); }
+ result.insert((copiedState, "rm_getSid"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_8 = state._tr_rm_getSid_Not_Found(isCaching);
+ for param in _trid_8.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.rm_getSid_Not_Found(_tmp_2, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("rm_getSid_Not_Found")); }
+ result.insert((copiedState, "rm_getSid_Not_Found"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_9 = state._tr_in_announceResourceManager(isCaching);
+ for param in _trid_9.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.in_announceResourceManager(_tmp_2, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("in_announceResourceManager")); }
+ result.insert((copiedState, "in_announceResourceManager"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_10 = state._tr_in_register_success(isCaching);
+ for param in _trid_10.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+ //model_check_transition_param_assignment
+ let mut _tmp_3 = _tmp_2.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_4 = _tmp_2.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.in_register_success(_tmp_4, _tmp_3, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("in_register_success")); }
+ result.insert((copiedState, "in_register_success"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_11 = state._tr_in_register_failed(isCaching);
+ for param in _trid_11.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.in_register_failed(_tmp_2, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("in_register_failed")); }
+ result.insert((copiedState, "in_register_failed"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_12 = state._tr_in_requestTargetSocket_Granted(isCaching);
+ for param in _trid_12.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+ //model_check_transition_param_assignment
+ let mut _tmp_3 = _tmp_2.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_4 = _tmp_2.projection1();
+ //model_check_transition_param_assignment
+ let mut _tmp_5 = _tmp_4.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_6 = _tmp_4.projection1();
+ //model_check_transition_param_assignment
+ let mut _tmp_7 = _tmp_6.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_8 = _tmp_6.projection1();
+ //model_check_transition_param_assignment
+ let mut _tmp_9 = _tmp_8.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_10 = _tmp_8.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.in_requestTargetSocket_Granted(_tmp_10, _tmp_9, _tmp_7, _tmp_5, _tmp_3, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("in_requestTargetSocket_Granted")); }
+ result.insert((copiedState, "in_requestTargetSocket_Granted"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_13 = state._tr_in_requestTargetSocket_NotGranted(isCaching);
+ for param in _trid_13.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_2 = param.projection1();
+ //model_check_transition_param_assignment
+ let mut _tmp_3 = _tmp_2.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_4 = _tmp_2.projection1();
+ //model_check_transition_param_assignment
+ let mut _tmp_5 = _tmp_4.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_6 = _tmp_4.projection1();
+ //model_check_transition_param_assignment
+ let mut _tmp_7 = _tmp_6.projection2();
+ //model_check_transition_param_assignment
+ let mut _tmp_8 = _tmp_6.projection1();
+
+ let mut copiedState = state.clone();
+ copiedState.in_requestTargetSocket_NotGranted(_tmp_8, _tmp_7, _tmp_5, _tmp_3, _tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("in_requestTargetSocket_NotGranted")); }
+ result.insert((copiedState, "in_requestTargetSocket_NotGranted"));
+ evaluated_transitions += 1;
+ }
+ //model_check_transition
+ let mut _trid_14 = state._tr_svc_register(isCaching);
+ for param in _trid_14.iter().cloned() {
+ //model_check_transition_body
+ //model_check_transition_param_assignment
+ let mut _tmp_1 = param;
+
+ let mut copiedState = state.clone();
+ copiedState.svc_register(_tmp_1);
+ if isCaching { copiedState.invalidate_caches(Self::get_guard_dependencies("svc_register")); }
+ result.insert((copiedState, "svc_register"));
+ evaluated_transitions += 1;
+ }
+
+
+ transitions.fetch_add(evaluated_transitions, Ordering::AcqRel);
+ return result;
+ }
+
+ //model_check_invariants
+ pub fn checkInvariants(state: ¬a_v2, last_op: &'static str, isCaching: bool) -> bool {
+ if isCaching {
+ let dependent_invariants_of_state = Self::get_invariant_dependencies(last_op);
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_1") {
+ if !state._check_inv_1() {
+ println!("_check_inv_1 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_2") {
+ if !state._check_inv_2() {
+ println!("_check_inv_2 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_3") {
+ if !state._check_inv_3() {
+ println!("_check_inv_3 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_4") {
+ if !state._check_inv_4() {
+ println!("_check_inv_4 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_5") {
+ if !state._check_inv_5() {
+ println!("_check_inv_5 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_6") {
+ if !state._check_inv_6() {
+ println!("_check_inv_6 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_7") {
+ if !state._check_inv_7() {
+ println!("_check_inv_7 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_8") {
+ if !state._check_inv_8() {
+ println!("_check_inv_8 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_9") {
+ if !state._check_inv_9() {
+ println!("_check_inv_9 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_10") {
+ if !state._check_inv_10() {
+ println!("_check_inv_10 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_11") {
+ if !state._check_inv_11() {
+ println!("_check_inv_11 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_12") {
+ if !state._check_inv_12() {
+ println!("_check_inv_12 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_13") {
+ if !state._check_inv_13() {
+ println!("_check_inv_13 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_14") {
+ if !state._check_inv_14() {
+ println!("_check_inv_14 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_15") {
+ if !state._check_inv_15() {
+ println!("_check_inv_15 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_16") {
+ if !state._check_inv_16() {
+ println!("_check_inv_16 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_17") {
+ if !state._check_inv_17() {
+ println!("_check_inv_17 failed!");
+ return false;
+ }
+ }
+ //model_check_invariant
+ if dependent_invariants_of_state.contains(&"_check_inv_18") {
+ if !state._check_inv_18() {
+ println!("_check_inv_18 failed!");
+ return false;
+ }
+ }
+ return true;
+ }
+ return !(!state._check_inv_1() || !state._check_inv_2() || !state._check_inv_3() || !state._check_inv_4() || !state._check_inv_5() || !state._check_inv_6() || !state._check_inv_7() || !state._check_inv_8() || !state._check_inv_9() || !state._check_inv_10() || !state._check_inv_11() || !state._check_inv_12() || !state._check_inv_13() || !state._check_inv_14() || !state._check_inv_15() || !state._check_inv_16() || !state._check_inv_17() || !state._check_inv_18());
+ }
+
+ //model_check_print
+ fn print_result(states: usize, transitions: u64, error_detected: bool) {
+ if !error_detected { println!("MODEL CHECKING SUCCESSFUL"); }
+ println!("Number of States: {}", states);
+ println!("Number of Transitions: {}", transitions);
+ }
+
+ //model_check_main
+ fn next(collection_m: Arc<Mutex<LinkedList<(nota_v2, &'static str)>>>, mc_type: MC_TYPE) -> (nota_v2, &'static str) {
+ let mut collection = collection_m.lock().unwrap();
+ return match mc_type {
+ MC_TYPE::BFS => collection.pop_front().unwrap(),
+ MC_TYPE::DFS => collection.pop_back().unwrap(),
+ MC_TYPE::MIXED => if collection.len() % 2 == 0 { collection.pop_front().unwrap() } else { collection.pop_back().unwrap() }
+ };
+ }
+
+ fn get_guard_dependencies(op: &'static str) -> Vec<&str> {
+ return match op {
+ //model_check_init_static
+ "in_register_success" => vec!["_tr_in_register_success", "_tr_in_requestTargetSocket_Granted", "_tr_in_requestTargetSocket_NotGranted", "_tr_constructor_socket"],
+ //model_check_init_static
+ "in_announceResourceManager" => vec!["_tr_in_announceResourceManager"],
+ //model_check_init_static
+ "in_requestTargetSocket_Granted" => vec!["_tr_in_requestTargetSocket_Granted", "_tr_in_requestTargetSocket_NotGranted", "_tr_constructor_socket"],
+ //model_check_init_static
+ "constructor_service" => vec!["_tr_constructor_service", "_tr_rm_getSid", "_tr_in_register_success", "_tr_svc_register", "_tr_in_register_failed", "_tr_rm_register", "_tr_rm_getSid_Not_Found", "_tr_rm_deregister"],
+ //model_check_init_static
+ "constructor_socket" => vec!["_tr_in_requestTargetSocket_Granted", "_tr_in_requestTargetSocket_NotGranted", "_tr_constructor_socket"],
+ //model_check_init_static
+ "in_requestTargetSocket_NotGranted" => vec![],
+ //model_check_init_static
+ "constructor_interconnectNode" => vec!["_tr_constructor_service", "_tr_in_register_success", "_tr_in_requestTargetSocket_Granted", "_tr_in_register_failed", "_tr_rm_register", "_tr_in_requestTargetSocket_NotGranted", "_tr_constructor_socket", "_tr_rm_deregister", "_tr_constructor_interconnectNode", "_tr_in_announceResourceManager"],
+ //model_check_init_static
+ "rm_getSid" => vec![],
+ //model_check_init_static
+ "rm_deregister" => vec![],
+ //model_check_init_static
+ "constructor_resourceManager" => vec!["_tr_rm_getSid", "_tr_constructor_resourceManager", "_tr_rm_register", "_tr_rm_getSid_Not_Found", "_tr_rm_deregister", "_tr_in_announceResourceManager"],
+ //model_check_init_static
+ "in_register_failed" => vec![],
+ //model_check_init_static
+ "rm_register" => vec![],
+ //model_check_init_static
+ "rm_getSid_Not_Found" => vec![],
+ //model_check_init_static
+ "svc_register" => vec!["_tr_svc_register"],
+ _ => vec![],
+ }
+ }
+
+ fn get_invariant_dependencies(op: &'static str) -> Vec<&str> {
+ return match op {
+ //model_check_init_static
+ "in_register_success" => vec!["_check_inv_5", "_check_inv_14", "_check_inv_13", "_check_inv_8", "_check_inv_12", "_check_inv_9"],
+ //model_check_init_static
+ "in_announceResourceManager" => vec!["_check_inv_11"],
+ //model_check_init_static
+ "in_requestTargetSocket_Granted" => vec!["_check_inv_15", "_check_inv_2", "_check_inv_10", "_check_inv_13", "_check_inv_12"],
+ //model_check_init_static
+ "constructor_service" => vec!["_check_inv_17", "_check_inv_16", "_check_inv_15", "_check_inv_3", "_check_inv_6", "_check_inv_14", "_check_inv_8"],
+ //model_check_init_static
+ "constructor_socket" => vec!["_check_inv_15", "_check_inv_2", "_check_inv_10", "_check_inv_13", "_check_inv_12"],
+ //model_check_init_static
+ "in_requestTargetSocket_NotGranted" => vec![],
+ //model_check_init_static
+ "constructor_interconnectNode" => vec!["_check_inv_16", "_check_inv_1", "_check_inv_10", "_check_inv_9", "_check_inv_11"],
+ //model_check_init_static
+ "rm_getSid" => vec![],
+ //model_check_init_static
+ "rm_deregister" => vec![],
+ //model_check_init_static
+ "constructor_resourceManager" => vec!["_check_inv_18", "_check_inv_6", "_check_inv_7", "_check_inv_4", "_check_inv_11"],
+ //model_check_init_static
+ "in_register_failed" => vec![],
+ //model_check_init_static
+ "rm_register" => vec![],
+ //model_check_init_static
+ "rm_getSid_Not_Found" => vec![],
+ //model_check_init_static
+ "svc_register" => vec!["_check_inv_17"],
+ _ => vec![],
+ }
+ }
+
+ fn model_check_single_threaded(mc_type: MC_TYPE, is_caching: bool, no_dead: bool, no_inv: bool) {
+ let mut machine = nota_v2::new();
+
+ let mut all_states = HashSet::<nota_v2>::new();
+ all_states.insert(machine.clone());
+
+ let states_to_process_mutex = Arc::new(Mutex::new(LinkedList::<(nota_v2, &'static str)>::new()));
+ states_to_process_mutex.lock().unwrap().push_back((machine.clone(), ""));
+
+ let num_transitions = Arc::new(AtomicU64::new(0));
+
+ let mut stop_threads = false;
+
+ while !stop_threads && !states_to_process_mutex.lock().unwrap().is_empty() {
+ let (mut state, last_op) = Self::next(Arc::clone(&states_to_process_mutex), mc_type);
+
+ let next_states = Self::generateNextStates(&mut state, is_caching, Arc::clone(&num_transitions));
+
+ if !no_inv && !Self::checkInvariants(&state, last_op, is_caching) {
+ println!("INVARIANT VIOLATED");
+ stop_threads = true;
+ }
+ if !no_dead && next_states.is_empty() {
+ print!("DEADLOCK DETECTED");
+ stop_threads = true;
+ }
+
+ next_states.into_iter()
+ .filter(|(next_state, _)| all_states.insert((*next_state).clone()))
+ .for_each(|(next_state, last_op)| states_to_process_mutex.lock().unwrap().push_back((next_state, last_op)));
+
+ if all_states.len() % 50000 == 0 {
+ println!("VISITED STATES: {}", all_states.len());
+ println!("EVALUATED TRANSITIONS: {}", num_transitions.load(Ordering::Acquire));
+ println!("-------------------");
+ }
+ }
+ Self::print_result(all_states.len(), num_transitions.load(Ordering::Acquire), stop_threads);
+ }
+
+ fn modelCheckMultiThreaded(mc_type: MC_TYPE, threads: usize, is_caching: bool, no_dead: bool, no_inv: bool) {
+ let threadPool = ThreadPool::new(threads);
+
+ let machine = nota_v2::new();
+
+ let all_states = Arc::new(DashSet::<nota_v2>::new());
+ all_states.insert(machine.clone());
+
+ let states_to_process_mutex = Arc::new(Mutex::new(LinkedList::<(nota_v2, &'static str)>::new()));
+ states_to_process_mutex.lock().unwrap().push_back((machine, ""));
+
+ let num_transitions = Arc::new(AtomicU64::new(0));
+
+ let mut stop_threads = false;
+ let mut spawned_tasks: u64 = 0;
+ let mut finished_tasks: u64 = 0;
+
+ let (tx, rx) = channel();
+ //println!("Thread {:?} starting threads", thread::current().id());
+ while !stop_threads && !states_to_process_mutex.lock().unwrap().is_empty() {
+ let (mut state, last_op) = Self::next(Arc::clone(&states_to_process_mutex), mc_type);
+
+ let states_to_process = Arc::clone(&states_to_process_mutex);
+ let transitions = Arc::clone(&num_transitions);
+ let states = Arc::clone(&all_states);
+ let tx = tx.clone();
+ //println!("Thread {:?} spawning a thread", thread::current().id());
+ threadPool.execute(move|| {
+ let next_states = Self::generateNextStates(&mut state, is_caching, transitions);
+ if !no_dead && next_states.is_empty() { let _ = tx.send(Err("DEADLOCK DETECTED")); }
+
+ //println!("Thread {:?} executing", thread::current().id());
+ next_states.into_iter()
+ .filter(|(next_state, _)| states.insert((*next_state).clone()))
+ .for_each(|(next_state, last_op)| states_to_process.lock().unwrap().push_back((next_state, last_op)));
+
+ if !no_inv && !Self::checkInvariants(&state, last_op, is_caching) {
+ let _ = tx.send(Err("INVARIANT VIOLATED"));
+ }
+ //println!("Thread {:?} done", thread::current().id());
+ let _ = tx.send(Ok(1));
+ });
+
+ spawned_tasks += 1;
+ if spawned_tasks % 50000 == 0 {
+ println!("VISITED STATES: {}", all_states.len());
+ println!("EVALUATED TRANSITIONS: {}", num_transitions.load(Ordering::Acquire));
+ println!("-------------------");
+ }
+
+ while states_to_process_mutex.lock().unwrap().is_empty() && spawned_tasks - finished_tasks > 0 {
+ //println!("Thread {:?} (main) waiting for a thread to finish", thread::current().id());
+ match rx.try_recv() {
+ Ok(val) => match val {
+ Ok(_) => finished_tasks += 1,
+ Err(msg) => { println!("{}", msg); stop_threads = true; },
+ },
+ Err(_) => (),
+ }
+ if threadPool.panic_count() > 0 { stop_threads = true; }
+ }
+ }
+
+ Self::print_result(all_states.len(), num_transitions.load(Ordering::Acquire), stop_threads);
+ }
+
+}
+
+
+fn main() {
+ let args: Vec<String> = env::args().collect();
+ if args.len() < 4 { panic!("Number of arguments errorneous"); }
+
+ let threads = args.get(2).unwrap().parse::<usize>().unwrap();
+ if threads <= 0 { panic!("Input for number of threads is wrong."); }
+
+ let is_caching = args.get(3).unwrap().parse::<bool>().unwrap();
+ let mc_type = match args.get(1).unwrap().as_str() {
+ "mixed" => MC_TYPE::MIXED,
+ "bf" => MC_TYPE::BFS,
+ "df" => MC_TYPE::DFS,
+ _ => panic!("Input for strategy is wrong.")
+ };
+
+ let mut no_dead = false;
+ let mut no_inv = false;
+
+ if args.len() > 4 {
+ for arg in args.iter().skip(4) {
+ match arg.as_str() {
+ "-nodead" => no_dead = true,
+ "-noinv" => no_inv = true,
+ _ => {}
+ }
+ }
+ }
+
+ if threads == 1 {
+ nota_v2::model_check_single_threaded(mc_type, is_caching, no_dead, no_inv);
+ } else {
+ nota_v2::modelCheckMultiThreaded(mc_type, threads, is_caching, no_dead, no_inv);
+ }
+}
--
GitLab