diff --git a/visualizations/LandingGear/HydraulicCircuit/LandingGear_R6-visualisation.js b/visualizations/LandingGear/HydraulicCircuit/LandingGear_R6-visualisation.js index 419e69fefe2d26c4e63411d4e7d95b5da152d837..6fd82bf349ed7ae623eb188a1795a84ad2d38ddb 100644 --- a/visualizations/LandingGear/HydraulicCircuit/LandingGear_R6-visualisation.js +++ b/visualizations/LandingGear/HydraulicCircuit/LandingGear_R6-visualisation.js @@ -28,7 +28,6 @@ window.onload = function() { } function initialize() { - window.setTimeout(function(){}, 1000); var _machine = new LandingGear_R6(); var _state_list = []; var _transition_list = []; diff --git a/visualizations/LandingGear/HydraulicCircuit/LandingGear_R6.js b/visualizations/LandingGear/HydraulicCircuit/LandingGear_R6.js index b8123a544b4eaf0ca492950b9e9f08437a7b00fe..ea454de1d442fc41547ca469c02d65490246014d 100644 --- a/visualizations/LandingGear/HydraulicCircuit/LandingGear_R6.js +++ b/visualizations/LandingGear/HydraulicCircuit/LandingGear_R6.js @@ -2,9 +2,7 @@ import { BTuple } from 'https://favu100.github.io/b2program/visualizations/Landi import { BBoolean } from 'https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BBoolean.js'; import { BRelation } from 'https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BRelation.js'; import { BSet } from 'https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BSet.js'; -import { BUtils } from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BUtils.js"; import { SelectError } from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BUtils.js"; -import * as immutable from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/immutable/dist/immutable.es.js"; export var enum_DOOR_STATE; (function (enum_DOOR_STATE) { enum_DOOR_STATE[enum_DOOR_STATE["open"] = 0] = "open"; @@ -221,6 +219,2645 @@ export class VALVE_STATE { static get_valve_open() { return new VALVE_STATE(enum_VALVE_STATE.valve_open); } static get_valve_closed() { return new VALVE_STATE(enum_VALVE_STATE.valve_closed); } } +class _ProjectionRead_begin_flying { + constructor(shock_absorber) { + this.shock_absorber = shock_absorber; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.shock_absorber.equals(o2.shock_absorber); + } + hashCode() { + let result = 1; + result = 31 * result + (this.shock_absorber.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_begin_flying { + constructor(shock_absorber) { + this.shock_absorber = shock_absorber; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.shock_absorber.equals(o2.shock_absorber); + } + hashCode() { + let result = 1; + result = 31 * result + (this.shock_absorber.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_begin_flying { + constructor(shock_absorber) { + this.shock_absorber = shock_absorber; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.shock_absorber.equals(o2.shock_absorber); + } + hashCode() { + let result = 1; + result = 31 * result + (this.shock_absorber.hashCode() << 1); + return result; + } +} +class _ProjectionRead_land_plane { + constructor(shock_absorber) { + this.shock_absorber = shock_absorber; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.shock_absorber.equals(o2.shock_absorber); + } + hashCode() { + let result = 1; + result = 31 * result + (this.shock_absorber.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_land_plane { + constructor(shock_absorber) { + this.shock_absorber = shock_absorber; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.shock_absorber.equals(o2.shock_absorber); + } + hashCode() { + let result = 1; + result = 31 * result + (this.shock_absorber.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_land_plane { + constructor(shock_absorber) { + this.shock_absorber = shock_absorber; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.shock_absorber.equals(o2.shock_absorber); + } + hashCode() { + let result = 1; + result = 31 * result + (this.shock_absorber.hashCode() << 1); + return result; + } +} +class _ProjectionRead_open_valve_door_open { + constructor(valve_open_door, open_EV) { + this.valve_open_door = valve_open_door; + this.open_EV = open_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_open_door.equals(o2.valve_open_door) && o1.open_EV.equals(o2.open_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_open_door.hashCode() << 1); + result = 31 * result + (this.open_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_open_valve_door_open { + constructor(valve_open_door, open_EV) { + this.valve_open_door = valve_open_door; + this.open_EV = open_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_open_door.equals(o2.valve_open_door) && o1.open_EV.equals(o2.open_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_open_door.hashCode() << 1); + result = 31 * result + (this.open_EV.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_open_valve_door_open { + constructor(valve_open_door) { + this.valve_open_door = valve_open_door; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_open_door.equals(o2.valve_open_door); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_open_door.hashCode() << 1); + return result; + } +} +class _ProjectionRead_close_valve_door_open { + constructor(valve_open_door, open_EV) { + this.valve_open_door = valve_open_door; + this.open_EV = open_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_open_door.equals(o2.valve_open_door) && o1.open_EV.equals(o2.open_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_open_door.hashCode() << 1); + result = 31 * result + (this.open_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_close_valve_door_open { + constructor(valve_open_door, open_EV) { + this.valve_open_door = valve_open_door; + this.open_EV = open_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_open_door.equals(o2.valve_open_door) && o1.open_EV.equals(o2.open_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_open_door.hashCode() << 1); + result = 31 * result + (this.open_EV.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_close_valve_door_open { + constructor(valve_open_door) { + this.valve_open_door = valve_open_door; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_open_door.equals(o2.valve_open_door); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_open_door.hashCode() << 1); + return result; + } +} +class _ProjectionRead_open_valve_door_close { + constructor(valve_close_door, close_EV) { + this.valve_close_door = valve_close_door; + this.close_EV = close_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_close_door.equals(o2.valve_close_door) && o1.close_EV.equals(o2.close_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_close_door.hashCode() << 1); + result = 31 * result + (this.close_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_open_valve_door_close { + constructor(valve_close_door, close_EV) { + this.valve_close_door = valve_close_door; + this.close_EV = close_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_close_door.equals(o2.valve_close_door) && o1.close_EV.equals(o2.close_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_close_door.hashCode() << 1); + result = 31 * result + (this.close_EV.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_open_valve_door_close { + constructor(valve_close_door) { + this.valve_close_door = valve_close_door; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_close_door.equals(o2.valve_close_door); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_close_door.hashCode() << 1); + return result; + } +} +class _ProjectionRead_close_valve_door_close { + constructor(valve_close_door, close_EV) { + this.valve_close_door = valve_close_door; + this.close_EV = close_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_close_door.equals(o2.valve_close_door) && o1.close_EV.equals(o2.close_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_close_door.hashCode() << 1); + result = 31 * result + (this.close_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_close_valve_door_close { + constructor(valve_close_door, close_EV) { + this.valve_close_door = valve_close_door; + this.close_EV = close_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_close_door.equals(o2.valve_close_door) && o1.close_EV.equals(o2.close_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_close_door.hashCode() << 1); + result = 31 * result + (this.close_EV.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_close_valve_door_close { + constructor(valve_close_door) { + this.valve_close_door = valve_close_door; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_close_door.equals(o2.valve_close_door); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_close_door.hashCode() << 1); + return result; + } +} +class _ProjectionRead_open_valve_retract_gear { + constructor(valve_retract_gear, retract_EV) { + this.valve_retract_gear = valve_retract_gear; + this.retract_EV = retract_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_retract_gear.equals(o2.valve_retract_gear) && o1.retract_EV.equals(o2.retract_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_retract_gear.hashCode() << 1); + result = 31 * result + (this.retract_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_open_valve_retract_gear { + constructor(valve_retract_gear, retract_EV) { + this.valve_retract_gear = valve_retract_gear; + this.retract_EV = retract_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_retract_gear.equals(o2.valve_retract_gear) && o1.retract_EV.equals(o2.retract_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_retract_gear.hashCode() << 1); + result = 31 * result + (this.retract_EV.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_open_valve_retract_gear { + constructor(valve_retract_gear) { + this.valve_retract_gear = valve_retract_gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_retract_gear.equals(o2.valve_retract_gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_retract_gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead_close_valve_retract_gear { + constructor(valve_retract_gear, retract_EV) { + this.valve_retract_gear = valve_retract_gear; + this.retract_EV = retract_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_retract_gear.equals(o2.valve_retract_gear) && o1.retract_EV.equals(o2.retract_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_retract_gear.hashCode() << 1); + result = 31 * result + (this.retract_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_close_valve_retract_gear { + constructor(valve_retract_gear, retract_EV) { + this.valve_retract_gear = valve_retract_gear; + this.retract_EV = retract_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_retract_gear.equals(o2.valve_retract_gear) && o1.retract_EV.equals(o2.retract_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_retract_gear.hashCode() << 1); + result = 31 * result + (this.retract_EV.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_close_valve_retract_gear { + constructor(valve_retract_gear) { + this.valve_retract_gear = valve_retract_gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_retract_gear.equals(o2.valve_retract_gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_retract_gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead_open_valve_extend_gear { + constructor(extend_EV, valve_extend_gear) { + this.extend_EV = extend_EV; + this.valve_extend_gear = valve_extend_gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.extend_EV.equals(o2.extend_EV) && o1.valve_extend_gear.equals(o2.valve_extend_gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.extend_EV.hashCode() << 1); + result = 31 * result + (this.valve_extend_gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_open_valve_extend_gear { + constructor(extend_EV, valve_extend_gear) { + this.extend_EV = extend_EV; + this.valve_extend_gear = valve_extend_gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.extend_EV.equals(o2.extend_EV) && o1.valve_extend_gear.equals(o2.valve_extend_gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.extend_EV.hashCode() << 1); + result = 31 * result + (this.valve_extend_gear.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_open_valve_extend_gear { + constructor(valve_extend_gear) { + this.valve_extend_gear = valve_extend_gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_extend_gear.equals(o2.valve_extend_gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_extend_gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead_close_valve_extend_gear { + constructor(extend_EV, valve_extend_gear) { + this.extend_EV = extend_EV; + this.valve_extend_gear = valve_extend_gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.extend_EV.equals(o2.extend_EV) && o1.valve_extend_gear.equals(o2.valve_extend_gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.extend_EV.hashCode() << 1); + result = 31 * result + (this.valve_extend_gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_close_valve_extend_gear { + constructor(extend_EV, valve_extend_gear) { + this.extend_EV = extend_EV; + this.valve_extend_gear = valve_extend_gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.extend_EV.equals(o2.extend_EV) && o1.valve_extend_gear.equals(o2.valve_extend_gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.extend_EV.hashCode() << 1); + result = 31 * result + (this.valve_extend_gear.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_close_valve_extend_gear { + constructor(valve_extend_gear) { + this.valve_extend_gear = valve_extend_gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_extend_gear.equals(o2.valve_extend_gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_extend_gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead_con_stimulate_open_door_valve { + constructor(handle, doors, open_EV, shock_absorber, close_EV, general_EV, gears) { + this.handle = handle; + this.doors = doors; + this.open_EV = open_EV; + this.shock_absorber = shock_absorber; + this.close_EV = close_EV; + this.general_EV = general_EV; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.open_EV.equals(o2.open_EV) && o1.shock_absorber.equals(o2.shock_absorber) && o1.close_EV.equals(o2.close_EV) && o1.general_EV.equals(o2.general_EV) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.open_EV.hashCode() << 1); + result = 31 * result + (this.shock_absorber.hashCode() << 1); + result = 31 * result + (this.close_EV.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_con_stimulate_open_door_valve { + constructor(handle, doors, open_EV, shock_absorber, close_EV, general_EV, gears) { + this.handle = handle; + this.doors = doors; + this.open_EV = open_EV; + this.shock_absorber = shock_absorber; + this.close_EV = close_EV; + this.general_EV = general_EV; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.open_EV.equals(o2.open_EV) && o1.shock_absorber.equals(o2.shock_absorber) && o1.close_EV.equals(o2.close_EV) && o1.general_EV.equals(o2.general_EV) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.open_EV.hashCode() << 1); + result = 31 * result + (this.shock_absorber.hashCode() << 1); + result = 31 * result + (this.close_EV.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_con_stimulate_open_door_valve { + constructor(open_EV) { + this.open_EV = open_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.open_EV.equals(o2.open_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.open_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead_con_stop_stimulate_open_door_valve { + constructor(extend_EV, handle, doors, open_EV, shock_absorber, general_EV, retract_EV, gears) { + this.extend_EV = extend_EV; + this.handle = handle; + this.doors = doors; + this.open_EV = open_EV; + this.shock_absorber = shock_absorber; + this.general_EV = general_EV; + this.retract_EV = retract_EV; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.extend_EV.equals(o2.extend_EV) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.open_EV.equals(o2.open_EV) && o1.shock_absorber.equals(o2.shock_absorber) && o1.general_EV.equals(o2.general_EV) && o1.retract_EV.equals(o2.retract_EV) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.extend_EV.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.open_EV.hashCode() << 1); + result = 31 * result + (this.shock_absorber.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + result = 31 * result + (this.retract_EV.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_con_stop_stimulate_open_door_valve { + constructor(extend_EV, handle, doors, open_EV, shock_absorber, general_EV, retract_EV, gears) { + this.extend_EV = extend_EV; + this.handle = handle; + this.doors = doors; + this.open_EV = open_EV; + this.shock_absorber = shock_absorber; + this.general_EV = general_EV; + this.retract_EV = retract_EV; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.extend_EV.equals(o2.extend_EV) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.open_EV.equals(o2.open_EV) && o1.shock_absorber.equals(o2.shock_absorber) && o1.general_EV.equals(o2.general_EV) && o1.retract_EV.equals(o2.retract_EV) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.extend_EV.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.open_EV.hashCode() << 1); + result = 31 * result + (this.shock_absorber.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + result = 31 * result + (this.retract_EV.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_con_stop_stimulate_open_door_valve { + constructor(open_EV) { + this.open_EV = open_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.open_EV.equals(o2.open_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.open_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead_con_stimulate_close_door_valve { + constructor(extend_EV, handle, doors, open_EV, shock_absorber, close_EV, general_EV, retract_EV, gears) { + this.extend_EV = extend_EV; + this.handle = handle; + this.doors = doors; + this.open_EV = open_EV; + this.shock_absorber = shock_absorber; + this.close_EV = close_EV; + this.general_EV = general_EV; + this.retract_EV = retract_EV; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.extend_EV.equals(o2.extend_EV) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.open_EV.equals(o2.open_EV) && o1.shock_absorber.equals(o2.shock_absorber) && o1.close_EV.equals(o2.close_EV) && o1.general_EV.equals(o2.general_EV) && o1.retract_EV.equals(o2.retract_EV) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.extend_EV.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.open_EV.hashCode() << 1); + result = 31 * result + (this.shock_absorber.hashCode() << 1); + result = 31 * result + (this.close_EV.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + result = 31 * result + (this.retract_EV.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_con_stimulate_close_door_valve { + constructor(extend_EV, handle, doors, open_EV, shock_absorber, close_EV, general_EV, retract_EV, gears) { + this.extend_EV = extend_EV; + this.handle = handle; + this.doors = doors; + this.open_EV = open_EV; + this.shock_absorber = shock_absorber; + this.close_EV = close_EV; + this.general_EV = general_EV; + this.retract_EV = retract_EV; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.extend_EV.equals(o2.extend_EV) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.open_EV.equals(o2.open_EV) && o1.shock_absorber.equals(o2.shock_absorber) && o1.close_EV.equals(o2.close_EV) && o1.general_EV.equals(o2.general_EV) && o1.retract_EV.equals(o2.retract_EV) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.extend_EV.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.open_EV.hashCode() << 1); + result = 31 * result + (this.shock_absorber.hashCode() << 1); + result = 31 * result + (this.close_EV.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + result = 31 * result + (this.retract_EV.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_con_stimulate_close_door_valve { + constructor(close_EV) { + this.close_EV = close_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.close_EV.equals(o2.close_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.close_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead_con_stop_stimulate_close_door_valve { + constructor(doors, shock_absorber, handle, close_EV, general_EV, gears) { + this.doors = doors; + this.shock_absorber = shock_absorber; + this.handle = handle; + this.close_EV = close_EV; + this.general_EV = general_EV; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.doors.equals(o2.doors) && o1.shock_absorber.equals(o2.shock_absorber) && o1.handle.equals(o2.handle) && o1.close_EV.equals(o2.close_EV) && o1.general_EV.equals(o2.general_EV) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.shock_absorber.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.close_EV.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_con_stop_stimulate_close_door_valve { + constructor(doors, shock_absorber, handle, close_EV, general_EV, gears) { + this.doors = doors; + this.shock_absorber = shock_absorber; + this.handle = handle; + this.close_EV = close_EV; + this.general_EV = general_EV; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.doors.equals(o2.doors) && o1.shock_absorber.equals(o2.shock_absorber) && o1.handle.equals(o2.handle) && o1.close_EV.equals(o2.close_EV) && o1.general_EV.equals(o2.general_EV) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.shock_absorber.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.close_EV.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_con_stop_stimulate_close_door_valve { + constructor(close_EV) { + this.close_EV = close_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.close_EV.equals(o2.close_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.close_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead_con_stimulate_retract_gear_valve { + constructor(extend_EV, doors, open_EV, shock_absorber, handle, general_EV, retract_EV, gears) { + this.extend_EV = extend_EV; + this.doors = doors; + this.open_EV = open_EV; + this.shock_absorber = shock_absorber; + this.handle = handle; + this.general_EV = general_EV; + this.retract_EV = retract_EV; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.extend_EV.equals(o2.extend_EV) && o1.doors.equals(o2.doors) && o1.open_EV.equals(o2.open_EV) && o1.shock_absorber.equals(o2.shock_absorber) && o1.handle.equals(o2.handle) && o1.general_EV.equals(o2.general_EV) && o1.retract_EV.equals(o2.retract_EV) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.extend_EV.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.open_EV.hashCode() << 1); + result = 31 * result + (this.shock_absorber.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + result = 31 * result + (this.retract_EV.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_con_stimulate_retract_gear_valve { + constructor(extend_EV, doors, open_EV, shock_absorber, handle, general_EV, retract_EV, gears) { + this.extend_EV = extend_EV; + this.doors = doors; + this.open_EV = open_EV; + this.shock_absorber = shock_absorber; + this.handle = handle; + this.general_EV = general_EV; + this.retract_EV = retract_EV; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.extend_EV.equals(o2.extend_EV) && o1.doors.equals(o2.doors) && o1.open_EV.equals(o2.open_EV) && o1.shock_absorber.equals(o2.shock_absorber) && o1.handle.equals(o2.handle) && o1.general_EV.equals(o2.general_EV) && o1.retract_EV.equals(o2.retract_EV) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.extend_EV.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.open_EV.hashCode() << 1); + result = 31 * result + (this.shock_absorber.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + result = 31 * result + (this.retract_EV.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_con_stimulate_retract_gear_valve { + constructor(retract_EV) { + this.retract_EV = retract_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.retract_EV.equals(o2.retract_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.retract_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead_con_stop_stimulate_retract_gear_valve { + constructor(handle, general_EV, retract_EV, gears) { + this.handle = handle; + this.general_EV = general_EV; + this.retract_EV = retract_EV; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.handle.equals(o2.handle) && o1.general_EV.equals(o2.general_EV) && o1.retract_EV.equals(o2.retract_EV) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + result = 31 * result + (this.retract_EV.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_con_stop_stimulate_retract_gear_valve { + constructor(handle, general_EV, retract_EV, gears) { + this.handle = handle; + this.general_EV = general_EV; + this.retract_EV = retract_EV; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.handle.equals(o2.handle) && o1.general_EV.equals(o2.general_EV) && o1.retract_EV.equals(o2.retract_EV) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + result = 31 * result + (this.retract_EV.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_con_stop_stimulate_retract_gear_valve { + constructor(retract_EV) { + this.retract_EV = retract_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.retract_EV.equals(o2.retract_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.retract_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead_con_stimulate_extend_gear_valve { + constructor(extend_EV, doors, open_EV, handle, general_EV, retract_EV, gears) { + this.extend_EV = extend_EV; + this.doors = doors; + this.open_EV = open_EV; + this.handle = handle; + this.general_EV = general_EV; + this.retract_EV = retract_EV; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.extend_EV.equals(o2.extend_EV) && o1.doors.equals(o2.doors) && o1.open_EV.equals(o2.open_EV) && o1.handle.equals(o2.handle) && o1.general_EV.equals(o2.general_EV) && o1.retract_EV.equals(o2.retract_EV) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.extend_EV.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.open_EV.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + result = 31 * result + (this.retract_EV.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_con_stimulate_extend_gear_valve { + constructor(extend_EV, doors, open_EV, handle, general_EV, retract_EV, gears) { + this.extend_EV = extend_EV; + this.doors = doors; + this.open_EV = open_EV; + this.handle = handle; + this.general_EV = general_EV; + this.retract_EV = retract_EV; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.extend_EV.equals(o2.extend_EV) && o1.doors.equals(o2.doors) && o1.open_EV.equals(o2.open_EV) && o1.handle.equals(o2.handle) && o1.general_EV.equals(o2.general_EV) && o1.retract_EV.equals(o2.retract_EV) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.extend_EV.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.open_EV.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + result = 31 * result + (this.retract_EV.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_con_stimulate_extend_gear_valve { + constructor(extend_EV) { + this.extend_EV = extend_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.extend_EV.equals(o2.extend_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.extend_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead_con_stop_stimulate_extend_gear_valve { + constructor(extend_EV, handle, general_EV, gears) { + this.extend_EV = extend_EV; + this.handle = handle; + this.general_EV = general_EV; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.extend_EV.equals(o2.extend_EV) && o1.handle.equals(o2.handle) && o1.general_EV.equals(o2.general_EV) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.extend_EV.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_con_stop_stimulate_extend_gear_valve { + constructor(extend_EV, handle, general_EV, gears) { + this.extend_EV = extend_EV; + this.handle = handle; + this.general_EV = general_EV; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.extend_EV.equals(o2.extend_EV) && o1.handle.equals(o2.handle) && o1.general_EV.equals(o2.general_EV) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.extend_EV.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_con_stop_stimulate_extend_gear_valve { + constructor(extend_EV) { + this.extend_EV = extend_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.extend_EV.equals(o2.extend_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.extend_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead_env_start_retracting_first { + constructor(door, handle, valve_retract_gear, doors, general_valve, gears, gear) { + this.door = door; + this.handle = handle; + this.valve_retract_gear = valve_retract_gear; + this.doors = doors; + this.general_valve = general_valve; + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.door.equals(o2.door) && o1.handle.equals(o2.handle) && o1.valve_retract_gear.equals(o2.valve_retract_gear) && o1.doors.equals(o2.doors) && o1.general_valve.equals(o2.general_valve) && o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.door.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.valve_retract_gear.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_env_start_retracting_first { + constructor(door, handle, valve_retract_gear, doors, general_valve, gears, gear) { + this.door = door; + this.handle = handle; + this.valve_retract_gear = valve_retract_gear; + this.doors = doors; + this.general_valve = general_valve; + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.door.equals(o2.door) && o1.handle.equals(o2.handle) && o1.valve_retract_gear.equals(o2.valve_retract_gear) && o1.doors.equals(o2.doors) && o1.general_valve.equals(o2.general_valve) && o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.door.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.valve_retract_gear.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_env_start_retracting_first { + constructor(gears, gear) { + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead_env_retract_gear_skip { + constructor(doors, general_valve, handle, gears) { + this.doors = doors; + this.general_valve = general_valve; + this.handle = handle; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.doors.equals(o2.doors) && o1.general_valve.equals(o2.general_valve) && o1.handle.equals(o2.handle) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_env_retract_gear_skip { + constructor(doors, general_valve, handle, gears) { + this.doors = doors; + this.general_valve = general_valve; + this.handle = handle; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.doors.equals(o2.doors) && o1.general_valve.equals(o2.general_valve) && o1.handle.equals(o2.handle) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_env_retract_gear_skip { + constructor(gears) { + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionRead_env_retract_gear_last { + constructor(door, handle, doors, general_valve, gears, gear) { + this.door = door; + this.handle = handle; + this.doors = doors; + this.general_valve = general_valve; + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.door.equals(o2.door) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.general_valve.equals(o2.general_valve) && o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.door.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_env_retract_gear_last { + constructor(door, handle, doors, general_valve, gears, gear) { + this.door = door; + this.handle = handle; + this.doors = doors; + this.general_valve = general_valve; + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.door.equals(o2.door) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.general_valve.equals(o2.general_valve) && o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.door.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_env_retract_gear_last { + constructor(gears, gear) { + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead_env_start_extending { + constructor(door, handle, doors, general_valve, valve_extend_gear, gears, gear) { + this.door = door; + this.handle = handle; + this.doors = doors; + this.general_valve = general_valve; + this.valve_extend_gear = valve_extend_gear; + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.door.equals(o2.door) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.general_valve.equals(o2.general_valve) && o1.valve_extend_gear.equals(o2.valve_extend_gear) && o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.door.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.valve_extend_gear.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_env_start_extending { + constructor(door, handle, doors, general_valve, valve_extend_gear, gears, gear) { + this.door = door; + this.handle = handle; + this.doors = doors; + this.general_valve = general_valve; + this.valve_extend_gear = valve_extend_gear; + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.door.equals(o2.door) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.general_valve.equals(o2.general_valve) && o1.valve_extend_gear.equals(o2.valve_extend_gear) && o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.door.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.valve_extend_gear.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_env_start_extending { + constructor(gears, gear) { + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead_env_extend_gear_last { + constructor(door, handle, doors, general_valve, gears, gear) { + this.door = door; + this.handle = handle; + this.doors = doors; + this.general_valve = general_valve; + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.door.equals(o2.door) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.general_valve.equals(o2.general_valve) && o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.door.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_env_extend_gear_last { + constructor(door, handle, doors, general_valve, gears, gear) { + this.door = door; + this.handle = handle; + this.doors = doors; + this.general_valve = general_valve; + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.door.equals(o2.door) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.general_valve.equals(o2.general_valve) && o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.door.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_env_extend_gear_last { + constructor(gears, gear) { + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead_env_extend_gear_skip { + constructor(doors, general_valve, handle, gears) { + this.doors = doors; + this.general_valve = general_valve; + this.handle = handle; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.doors.equals(o2.doors) && o1.general_valve.equals(o2.general_valve) && o1.handle.equals(o2.handle) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_env_extend_gear_skip { + constructor(doors, general_valve, handle, gears) { + this.doors = doors; + this.general_valve = general_valve; + this.handle = handle; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.doors.equals(o2.doors) && o1.general_valve.equals(o2.general_valve) && o1.handle.equals(o2.handle) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_env_extend_gear_skip { + constructor(gears) { + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionRead_env_start_open_door { + constructor(valve_open_door, door, handle, doors, general_valve, gears, gear) { + this.valve_open_door = valve_open_door; + this.door = door; + this.handle = handle; + this.doors = doors; + this.general_valve = general_valve; + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_open_door.equals(o2.valve_open_door) && o1.door.equals(o2.door) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.general_valve.equals(o2.general_valve) && o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_open_door.hashCode() << 1); + result = 31 * result + (this.door.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_env_start_open_door { + constructor(valve_open_door, door, handle, doors, general_valve, gears, gear) { + this.valve_open_door = valve_open_door; + this.door = door; + this.handle = handle; + this.doors = doors; + this.general_valve = general_valve; + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_open_door.equals(o2.valve_open_door) && o1.door.equals(o2.door) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.general_valve.equals(o2.general_valve) && o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_open_door.hashCode() << 1); + result = 31 * result + (this.door.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_env_start_open_door { + constructor(doors, door) { + this.doors = doors; + this.door = door; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.doors.equals(o2.doors) && o1.door.equals(o2.door); + } + hashCode() { + let result = 1; + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.door.hashCode() << 1); + return result; + } +} +class _ProjectionRead_env_open_door_last { + constructor(valve_open_door, door, handle, doors, general_valve, gears, gear) { + this.valve_open_door = valve_open_door; + this.door = door; + this.handle = handle; + this.doors = doors; + this.general_valve = general_valve; + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_open_door.equals(o2.valve_open_door) && o1.door.equals(o2.door) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.general_valve.equals(o2.general_valve) && o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_open_door.hashCode() << 1); + result = 31 * result + (this.door.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_env_open_door_last { + constructor(valve_open_door, door, handle, doors, general_valve, gears, gear) { + this.valve_open_door = valve_open_door; + this.door = door; + this.handle = handle; + this.doors = doors; + this.general_valve = general_valve; + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_open_door.equals(o2.valve_open_door) && o1.door.equals(o2.door) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.general_valve.equals(o2.general_valve) && o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_open_door.hashCode() << 1); + result = 31 * result + (this.door.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_env_open_door_last { + constructor(doors, door) { + this.doors = doors; + this.door = door; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.doors.equals(o2.doors) && o1.door.equals(o2.door); + } + hashCode() { + let result = 1; + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.door.hashCode() << 1); + return result; + } +} +class _ProjectionRead_env_open_door_skip { + constructor(valve_open_door, handle, doors, general_valve, gears) { + this.valve_open_door = valve_open_door; + this.handle = handle; + this.doors = doors; + this.general_valve = general_valve; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_open_door.equals(o2.valve_open_door) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.general_valve.equals(o2.general_valve) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_open_door.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_env_open_door_skip { + constructor(valve_open_door, handle, doors, general_valve, gears) { + this.valve_open_door = valve_open_door; + this.handle = handle; + this.doors = doors; + this.general_valve = general_valve; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_open_door.equals(o2.valve_open_door) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.general_valve.equals(o2.general_valve) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_open_door.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_env_open_door_skip { + constructor(doors) { + this.doors = doors; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.doors.equals(o2.doors); + } + hashCode() { + let result = 1; + result = 31 * result + (this.doors.hashCode() << 1); + return result; + } +} +class _ProjectionRead_env_start_close_door { + constructor(door, valve_close_door, handle, doors, general_valve, gears, gear) { + this.door = door; + this.valve_close_door = valve_close_door; + this.handle = handle; + this.doors = doors; + this.general_valve = general_valve; + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.door.equals(o2.door) && o1.valve_close_door.equals(o2.valve_close_door) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.general_valve.equals(o2.general_valve) && o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.door.hashCode() << 1); + result = 31 * result + (this.valve_close_door.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_env_start_close_door { + constructor(door, valve_close_door, handle, doors, general_valve, gears, gear) { + this.door = door; + this.valve_close_door = valve_close_door; + this.handle = handle; + this.doors = doors; + this.general_valve = general_valve; + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.door.equals(o2.door) && o1.valve_close_door.equals(o2.valve_close_door) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.general_valve.equals(o2.general_valve) && o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.door.hashCode() << 1); + result = 31 * result + (this.valve_close_door.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_env_start_close_door { + constructor(doors, door) { + this.doors = doors; + this.door = door; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.doors.equals(o2.doors) && o1.door.equals(o2.door); + } + hashCode() { + let result = 1; + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.door.hashCode() << 1); + return result; + } +} +class _ProjectionRead_env_close_door { + constructor(door, valve_close_door, handle, doors, shock_absorber, general_valve, gears, gear) { + this.door = door; + this.valve_close_door = valve_close_door; + this.handle = handle; + this.doors = doors; + this.shock_absorber = shock_absorber; + this.general_valve = general_valve; + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.door.equals(o2.door) && o1.valve_close_door.equals(o2.valve_close_door) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.shock_absorber.equals(o2.shock_absorber) && o1.general_valve.equals(o2.general_valve) && o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.door.hashCode() << 1); + result = 31 * result + (this.valve_close_door.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.shock_absorber.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_env_close_door { + constructor(door, valve_close_door, handle, doors, shock_absorber, general_valve, gears, gear) { + this.door = door; + this.valve_close_door = valve_close_door; + this.handle = handle; + this.doors = doors; + this.shock_absorber = shock_absorber; + this.general_valve = general_valve; + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.door.equals(o2.door) && o1.valve_close_door.equals(o2.valve_close_door) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.shock_absorber.equals(o2.shock_absorber) && o1.general_valve.equals(o2.general_valve) && o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.door.hashCode() << 1); + result = 31 * result + (this.valve_close_door.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.shock_absorber.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_env_close_door { + constructor(doors, door) { + this.doors = doors; + this.door = door; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.doors.equals(o2.doors) && o1.door.equals(o2.door); + } + hashCode() { + let result = 1; + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.door.hashCode() << 1); + return result; + } +} +class _ProjectionRead_env_close_door_skip { + constructor(valve_close_door, handle, doors, shock_absorber, general_valve, gears) { + this.valve_close_door = valve_close_door; + this.handle = handle; + this.doors = doors; + this.shock_absorber = shock_absorber; + this.general_valve = general_valve; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_close_door.equals(o2.valve_close_door) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.shock_absorber.equals(o2.shock_absorber) && o1.general_valve.equals(o2.general_valve) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_close_door.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.shock_absorber.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_env_close_door_skip { + constructor(valve_close_door, handle, doors, shock_absorber, general_valve, gears) { + this.valve_close_door = valve_close_door; + this.handle = handle; + this.doors = doors; + this.shock_absorber = shock_absorber; + this.general_valve = general_valve; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_close_door.equals(o2.valve_close_door) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.shock_absorber.equals(o2.shock_absorber) && o1.general_valve.equals(o2.general_valve) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_close_door.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.shock_absorber.hashCode() << 1); + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_env_close_door_skip { + constructor(doors) { + this.doors = doors; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.doors.equals(o2.doors); + } + hashCode() { + let result = 1; + result = 31 * result + (this.doors.hashCode() << 1); + return result; + } +} +class _ProjectionRead_toggle_handle_up { + constructor(handle) { + this.handle = handle; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.handle.equals(o2.handle); + } + hashCode() { + let result = 1; + result = 31 * result + (this.handle.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_toggle_handle_up { + constructor(handle) { + this.handle = handle; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.handle.equals(o2.handle); + } + hashCode() { + let result = 1; + result = 31 * result + (this.handle.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_toggle_handle_up { + constructor(handle, handle_move) { + this.handle = handle; + this.handle_move = handle_move; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.handle.equals(o2.handle) && o1.handle_move.equals(o2.handle_move); + } + hashCode() { + let result = 1; + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.handle_move.hashCode() << 1); + return result; + } +} +class _ProjectionRead_toggle_handle_down { + constructor(handle) { + this.handle = handle; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.handle.equals(o2.handle); + } + hashCode() { + let result = 1; + result = 31 * result + (this.handle.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_toggle_handle_down { + constructor(handle) { + this.handle = handle; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.handle.equals(o2.handle); + } + hashCode() { + let result = 1; + result = 31 * result + (this.handle.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_toggle_handle_down { + constructor(handle, handle_move) { + this.handle = handle; + this.handle_move = handle_move; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.handle.equals(o2.handle) && o1.handle_move.equals(o2.handle_move); + } + hashCode() { + let result = 1; + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.handle_move.hashCode() << 1); + return result; + } +} +class _ProjectionRead_con_stimulate_general_valve { + constructor(handle_move, general_EV) { + this.handle_move = handle_move; + this.general_EV = general_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.handle_move.equals(o2.handle_move) && o1.general_EV.equals(o2.general_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.handle_move.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_con_stimulate_general_valve { + constructor(handle_move, general_EV) { + this.handle_move = handle_move; + this.general_EV = general_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.handle_move.equals(o2.handle_move) && o1.general_EV.equals(o2.general_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.handle_move.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_con_stimulate_general_valve { + constructor(general_EV) { + this.general_EV = general_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.general_EV.equals(o2.general_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.general_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead_con_stop_stimulate_general_valve { + constructor(extend_EV, handle, doors, open_EV, close_EV, general_EV, retract_EV, gears) { + this.extend_EV = extend_EV; + this.handle = handle; + this.doors = doors; + this.open_EV = open_EV; + this.close_EV = close_EV; + this.general_EV = general_EV; + this.retract_EV = retract_EV; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.extend_EV.equals(o2.extend_EV) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.open_EV.equals(o2.open_EV) && o1.close_EV.equals(o2.close_EV) && o1.general_EV.equals(o2.general_EV) && o1.retract_EV.equals(o2.retract_EV) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.extend_EV.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.open_EV.hashCode() << 1); + result = 31 * result + (this.close_EV.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + result = 31 * result + (this.retract_EV.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_con_stop_stimulate_general_valve { + constructor(extend_EV, handle, doors, open_EV, close_EV, general_EV, retract_EV, gears) { + this.extend_EV = extend_EV; + this.handle = handle; + this.doors = doors; + this.open_EV = open_EV; + this.close_EV = close_EV; + this.general_EV = general_EV; + this.retract_EV = retract_EV; + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.extend_EV.equals(o2.extend_EV) && o1.handle.equals(o2.handle) && o1.doors.equals(o2.doors) && o1.open_EV.equals(o2.open_EV) && o1.close_EV.equals(o2.close_EV) && o1.general_EV.equals(o2.general_EV) && o1.retract_EV.equals(o2.retract_EV) && o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.extend_EV.hashCode() << 1); + result = 31 * result + (this.handle.hashCode() << 1); + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.open_EV.hashCode() << 1); + result = 31 * result + (this.close_EV.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + result = 31 * result + (this.retract_EV.hashCode() << 1); + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_con_stop_stimulate_general_valve { + constructor(handle_move, general_EV) { + this.handle_move = handle_move; + this.general_EV = general_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.handle_move.equals(o2.handle_move) && o1.general_EV.equals(o2.general_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.handle_move.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead_evn_open_general_valve { + constructor(general_valve, analogical_switch, general_EV) { + this.general_valve = general_valve; + this.analogical_switch = analogical_switch; + this.general_EV = general_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.general_valve.equals(o2.general_valve) && o1.analogical_switch.equals(o2.analogical_switch) && o1.general_EV.equals(o2.general_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.analogical_switch.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_evn_open_general_valve { + constructor(general_valve, analogical_switch, general_EV) { + this.general_valve = general_valve; + this.analogical_switch = analogical_switch; + this.general_EV = general_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.general_valve.equals(o2.general_valve) && o1.analogical_switch.equals(o2.analogical_switch) && o1.general_EV.equals(o2.general_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.analogical_switch.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_evn_open_general_valve { + constructor(general_valve) { + this.general_valve = general_valve; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.general_valve.equals(o2.general_valve); + } + hashCode() { + let result = 1; + result = 31 * result + (this.general_valve.hashCode() << 1); + return result; + } +} +class _ProjectionRead_evn_close_general_valve { + constructor(general_valve, analogical_switch, general_EV) { + this.general_valve = general_valve; + this.analogical_switch = analogical_switch; + this.general_EV = general_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.general_valve.equals(o2.general_valve) && o1.analogical_switch.equals(o2.analogical_switch) && o1.general_EV.equals(o2.general_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.analogical_switch.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_evn_close_general_valve { + constructor(general_valve, analogical_switch, general_EV) { + this.general_valve = general_valve; + this.analogical_switch = analogical_switch; + this.general_EV = general_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.general_valve.equals(o2.general_valve) && o1.analogical_switch.equals(o2.analogical_switch) && o1.general_EV.equals(o2.general_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.general_valve.hashCode() << 1); + result = 31 * result + (this.analogical_switch.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_evn_close_general_valve { + constructor(general_valve) { + this.general_valve = general_valve; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.general_valve.equals(o2.general_valve); + } + hashCode() { + let result = 1; + result = 31 * result + (this.general_valve.hashCode() << 1); + return result; + } +} +class _ProjectionRead_env_close_analogical_switch { + constructor(analogical_switch, handle_move) { + this.analogical_switch = analogical_switch; + this.handle_move = handle_move; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.analogical_switch.equals(o2.analogical_switch) && o1.handle_move.equals(o2.handle_move); + } + hashCode() { + let result = 1; + result = 31 * result + (this.analogical_switch.hashCode() << 1); + result = 31 * result + (this.handle_move.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_env_close_analogical_switch { + constructor(analogical_switch, handle_move) { + this.analogical_switch = analogical_switch; + this.handle_move = handle_move; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.analogical_switch.equals(o2.analogical_switch) && o1.handle_move.equals(o2.handle_move); + } + hashCode() { + let result = 1; + result = 31 * result + (this.analogical_switch.hashCode() << 1); + result = 31 * result + (this.handle_move.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_env_close_analogical_switch { + constructor(analogical_switch) { + this.analogical_switch = analogical_switch; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.analogical_switch.equals(o2.analogical_switch); + } + hashCode() { + let result = 1; + result = 31 * result + (this.analogical_switch.hashCode() << 1); + return result; + } +} +class _ProjectionRead_env_open_analogical_switch { + constructor(analogical_switch) { + this.analogical_switch = analogical_switch; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.analogical_switch.equals(o2.analogical_switch); + } + hashCode() { + let result = 1; + result = 31 * result + (this.analogical_switch.hashCode() << 1); + return result; + } +} +class _ProjectionRead__tr_env_open_analogical_switch { + constructor(analogical_switch) { + this.analogical_switch = analogical_switch; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.analogical_switch.equals(o2.analogical_switch); + } + hashCode() { + let result = 1; + result = 31 * result + (this.analogical_switch.hashCode() << 1); + return result; + } +} +class _ProjectionWrite_env_open_analogical_switch { + constructor(analogical_switch) { + this.analogical_switch = analogical_switch; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.analogical_switch.equals(o2.analogical_switch); + } + hashCode() { + let result = 1; + result = 31 * result + (this.analogical_switch.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_1 { + constructor(analogical_switch) { + this.analogical_switch = analogical_switch; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.analogical_switch.equals(o2.analogical_switch); + } + hashCode() { + let result = 1; + result = 31 * result + (this.analogical_switch.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_2 { + constructor(general_EV) { + this.general_EV = general_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.general_EV.equals(o2.general_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.general_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_3 { + constructor(general_valve) { + this.general_valve = general_valve; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.general_valve.equals(o2.general_valve); + } + hashCode() { + let result = 1; + result = 31 * result + (this.general_valve.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_4 { + constructor(handle_move) { + this.handle_move = handle_move; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.handle_move.equals(o2.handle_move); + } + hashCode() { + let result = 1; + result = 31 * result + (this.handle_move.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_5 { + constructor(close_EV) { + this.close_EV = close_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.close_EV.equals(o2.close_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.close_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_6 { + constructor(extend_EV) { + this.extend_EV = extend_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.extend_EV.equals(o2.extend_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.extend_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_7 { + constructor(open_EV) { + this.open_EV = open_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.open_EV.equals(o2.open_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.open_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_8 { + constructor(retract_EV) { + this.retract_EV = retract_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.retract_EV.equals(o2.retract_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.retract_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_9 { + constructor(shock_absorber) { + this.shock_absorber = shock_absorber; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.shock_absorber.equals(o2.shock_absorber); + } + hashCode() { + let result = 1; + result = 31 * result + (this.shock_absorber.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_10 { + constructor(valve_close_door) { + this.valve_close_door = valve_close_door; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_close_door.equals(o2.valve_close_door); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_close_door.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_11 { + constructor(valve_extend_gear) { + this.valve_extend_gear = valve_extend_gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_extend_gear.equals(o2.valve_extend_gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_extend_gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_12 { + constructor(valve_open_door) { + this.valve_open_door = valve_open_door; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_open_door.equals(o2.valve_open_door); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_open_door.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_13 { + constructor(valve_retract_gear) { + this.valve_retract_gear = valve_retract_gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.valve_retract_gear.equals(o2.valve_retract_gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.valve_retract_gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_14 { + constructor(handle) { + this.handle = handle; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.handle.equals(o2.handle); + } + hashCode() { + let result = 1; + result = 31 * result + (this.handle.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_15 { + constructor(door) { + this.door = door; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.door.equals(o2.door); + } + hashCode() { + let result = 1; + result = 31 * result + (this.door.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_16 { + constructor(gear) { + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_17 { + constructor(extend_EV, open_EV, close_EV, general_EV, retract_EV) { + this.extend_EV = extend_EV; + this.open_EV = open_EV; + this.close_EV = close_EV; + this.general_EV = general_EV; + this.retract_EV = retract_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.extend_EV.equals(o2.extend_EV) && o1.open_EV.equals(o2.open_EV) && o1.close_EV.equals(o2.close_EV) && o1.general_EV.equals(o2.general_EV) && o1.retract_EV.equals(o2.retract_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.extend_EV.hashCode() << 1); + result = 31 * result + (this.open_EV.hashCode() << 1); + result = 31 * result + (this.close_EV.hashCode() << 1); + result = 31 * result + (this.general_EV.hashCode() << 1); + result = 31 * result + (this.retract_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_18 { + constructor(open_EV, close_EV) { + this.open_EV = open_EV; + this.close_EV = close_EV; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.open_EV.equals(o2.open_EV) && o1.close_EV.equals(o2.close_EV); + } + hashCode() { + let result = 1; + result = 31 * result + (this.open_EV.hashCode() << 1); + result = 31 * result + (this.close_EV.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_19 { + constructor(gears) { + this.gears = gears; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.gears.equals(o2.gears); + } + hashCode() { + let result = 1; + result = 31 * result + (this.gears.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_20 { + constructor(doors) { + this.doors = doors; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.doors.equals(o2.doors); + } + hashCode() { + let result = 1; + result = 31 * result + (this.doors.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_21 { + constructor(doors, door) { + this.doors = doors; + this.door = door; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.doors.equals(o2.doors) && o1.door.equals(o2.door); + } + hashCode() { + let result = 1; + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.door.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_22 { + constructor(doors, door) { + this.doors = doors; + this.door = door; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.doors.equals(o2.doors) && o1.door.equals(o2.door); + } + hashCode() { + let result = 1; + result = 31 * result + (this.doors.hashCode() << 1); + result = 31 * result + (this.door.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_23 { + constructor(gears, gear) { + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_24 { + constructor(gears, gear) { + this.gears = gears; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.gears.equals(o2.gears) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.gears.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} +class _ProjectionRead__check_inv_25 { + constructor(door, gear) { + this.door = door; + this.gear = gear; + } + equals(other) { + let o1 = this; + let o2 = other; + return o1.door.equals(o2.door) && o1.gear.equals(o2.gear); + } + hashCode() { + let result = 1; + result = 31 * result + (this.door.hashCode() << 1); + result = 31 * result + (this.gear.hashCode() << 1); + return result; + } +} export var Type; (function (Type) { Type[Type["BFS"] = 0] = "BFS"; @@ -229,9 +2866,6 @@ export var Type; })(Type || (Type = {})); export default class LandingGear_R6 { constructor(copy) { - this.dependentGuard = immutable.Set(); - this.guardCache = immutable.Map(); - this.dependentInvariant = immutable.Set(); if (copy) { this.analogical_switch = copy.analogical_switch; this.general_EV = copy.general_EV; @@ -418,7 +3052,7 @@ export default class LandingGear_R6 { } } env_start_retracting_first(gr) { - if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.domain().elementOf(gr).booleanValue() && this.doors.range().equal(new BSet(new DOOR_STATE(enum_DOOR_STATE.open))).booleanValue()).booleanValue() && this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue()).booleanValue() && this.gears.functionCall(gr).equal(new GEAR_STATE(enum_GEAR_STATE.extended)).booleanValue()).booleanValue() && this.valve_retract_gear.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && new BSet(new GEAR_STATE(enum_GEAR_STATE.extended), new GEAR_STATE(enum_GEAR_STATE.gear_moving)).elementOf(this.gear).booleanValue()).booleanValue() && this.door.equal(new DOOR_STATE(enum_DOOR_STATE.open)).booleanValue())).booleanValue()) { + if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.isInDomain(gr).booleanValue() && this.doors.range().equal(new BSet(new DOOR_STATE(enum_DOOR_STATE.open))).booleanValue()).booleanValue() && this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue()).booleanValue() && this.gears.functionCall(gr).equal(new GEAR_STATE(enum_GEAR_STATE.extended)).booleanValue()).booleanValue() && this.valve_retract_gear.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && new BSet(new GEAR_STATE(enum_GEAR_STATE.extended), new GEAR_STATE(enum_GEAR_STATE.gear_moving)).elementOf(this.gear).booleanValue()).booleanValue() && this.door.equal(new DOOR_STATE(enum_DOOR_STATE.open)).booleanValue())).booleanValue()) { let _ld_gears = this.gears; this.gears = _ld_gears.override(new BRelation(new BTuple(gr, new GEAR_STATE(enum_GEAR_STATE.gear_moving)))); this.gear = new GEAR_STATE(enum_GEAR_STATE.gear_moving); @@ -428,7 +3062,7 @@ export default class LandingGear_R6 { } } env_retract_gear_skip(gr) { - if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.domain().elementOf(gr).booleanValue() && this.doors.range().equal(new BSet(new DOOR_STATE(enum_DOOR_STATE.open))).booleanValue()).booleanValue() && this.gears.relationImage(LandingGear_R6._POSITION.difference(new BSet(gr))).unequal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue()).booleanValue() && this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue()).booleanValue() && this.gears.functionCall(gr).equal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue())).booleanValue()) { + if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.isInDomain(gr).booleanValue() && this.doors.range().equal(new BSet(new DOOR_STATE(enum_DOOR_STATE.open))).booleanValue()).booleanValue() && this.gears.relationImage(LandingGear_R6._POSITION.difference(new BSet(gr))).unequal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue()).booleanValue() && this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue()).booleanValue() && this.gears.functionCall(gr).equal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue())).booleanValue()) { this.gears = this.gears.override(new BRelation(new BTuple(gr, new GEAR_STATE(enum_GEAR_STATE.retracted)))); } else { @@ -436,7 +3070,7 @@ export default class LandingGear_R6 { } } env_retract_gear_last(gr) { - if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.domain().elementOf(gr).booleanValue() && this.doors.range().equal(new BSet(new DOOR_STATE(enum_DOOR_STATE.open))).booleanValue()).booleanValue() && this.gears.relationImage(LandingGear_R6._POSITION.difference(new BSet(gr))).equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue()).booleanValue() && this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue()).booleanValue() && this.gears.functionCall(gr).equal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.door.equal(new DOOR_STATE(enum_DOOR_STATE.open)).booleanValue())).booleanValue()) { + if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.isInDomain(gr).booleanValue() && this.doors.range().equal(new BSet(new DOOR_STATE(enum_DOOR_STATE.open))).booleanValue()).booleanValue() && this.gears.relationImage(LandingGear_R6._POSITION.difference(new BSet(gr))).equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue()).booleanValue() && this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue()).booleanValue() && this.gears.functionCall(gr).equal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.door.equal(new DOOR_STATE(enum_DOOR_STATE.open)).booleanValue())).booleanValue()) { let _ld_gears = this.gears; this.gears = _ld_gears.override(new BRelation(new BTuple(gr, new GEAR_STATE(enum_GEAR_STATE.retracted)))); this.gear = new GEAR_STATE(enum_GEAR_STATE.retracted); @@ -446,7 +3080,7 @@ export default class LandingGear_R6 { } } env_start_extending(gr) { - if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.domain().elementOf(gr).booleanValue() && this.doors.range().equal(new BSet(new DOOR_STATE(enum_DOOR_STATE.open))).booleanValue()).booleanValue() && this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue()).booleanValue() && this.gears.functionCall(gr).equal(new GEAR_STATE(enum_GEAR_STATE.retracted)).booleanValue()).booleanValue() && this.valve_extend_gear.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && new BSet(new GEAR_STATE(enum_GEAR_STATE.gear_moving), new GEAR_STATE(enum_GEAR_STATE.retracted)).elementOf(this.gear).booleanValue()).booleanValue() && this.door.equal(new DOOR_STATE(enum_DOOR_STATE.open)).booleanValue())).booleanValue()) { + if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.isInDomain(gr).booleanValue() && this.doors.range().equal(new BSet(new DOOR_STATE(enum_DOOR_STATE.open))).booleanValue()).booleanValue() && this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue()).booleanValue() && this.gears.functionCall(gr).equal(new GEAR_STATE(enum_GEAR_STATE.retracted)).booleanValue()).booleanValue() && this.valve_extend_gear.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && new BSet(new GEAR_STATE(enum_GEAR_STATE.gear_moving), new GEAR_STATE(enum_GEAR_STATE.retracted)).elementOf(this.gear).booleanValue()).booleanValue() && this.door.equal(new DOOR_STATE(enum_DOOR_STATE.open)).booleanValue())).booleanValue()) { let _ld_gears = this.gears; this.gears = _ld_gears.override(new BRelation(new BTuple(gr, new GEAR_STATE(enum_GEAR_STATE.gear_moving)))); this.gear = new GEAR_STATE(enum_GEAR_STATE.gear_moving); @@ -456,7 +3090,7 @@ export default class LandingGear_R6 { } } env_extend_gear_last(gr) { - if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.domain().elementOf(gr).booleanValue() && this.doors.range().equal(new BSet(new DOOR_STATE(enum_DOOR_STATE.open))).booleanValue()).booleanValue() && this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue()).booleanValue() && this.gears.relationImage(LandingGear_R6._POSITION.difference(new BSet(gr))).equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue() && this.gears.functionCall(gr).equal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.door.equal(new DOOR_STATE(enum_DOOR_STATE.open)).booleanValue())).booleanValue()) { + if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.isInDomain(gr).booleanValue() && this.doors.range().equal(new BSet(new DOOR_STATE(enum_DOOR_STATE.open))).booleanValue()).booleanValue() && this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue()).booleanValue() && this.gears.relationImage(LandingGear_R6._POSITION.difference(new BSet(gr))).equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue() && this.gears.functionCall(gr).equal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.door.equal(new DOOR_STATE(enum_DOOR_STATE.open)).booleanValue())).booleanValue()) { let _ld_gears = this.gears; this.gears = _ld_gears.override(new BRelation(new BTuple(gr, new GEAR_STATE(enum_GEAR_STATE.extended)))); this.gear = new GEAR_STATE(enum_GEAR_STATE.extended); @@ -466,7 +3100,7 @@ export default class LandingGear_R6 { } } env_extend_gear_skip(gr) { - if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.domain().elementOf(gr).booleanValue() && this.doors.range().equal(new BSet(new DOOR_STATE(enum_DOOR_STATE.open))).booleanValue()).booleanValue() && this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue()).booleanValue() && this.gears.relationImage(LandingGear_R6._POSITION.difference(new BSet(gr))).unequal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue() && this.gears.functionCall(gr).equal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue())).booleanValue()) { + if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.isInDomain(gr).booleanValue() && this.doors.range().equal(new BSet(new DOOR_STATE(enum_DOOR_STATE.open))).booleanValue()).booleanValue() && this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue()).booleanValue() && this.gears.relationImage(LandingGear_R6._POSITION.difference(new BSet(gr))).unequal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue() && this.gears.functionCall(gr).equal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue())).booleanValue()) { this.gears = this.gears.override(new BRelation(new BTuple(gr, new GEAR_STATE(enum_GEAR_STATE.extended)))); } else { @@ -474,7 +3108,7 @@ export default class LandingGear_R6 { } } env_start_open_door(gr) { - if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.domain().elementOf(gr).booleanValue() && this.doors.functionCall(gr).equal(new DOOR_STATE(enum_DOOR_STATE.closed)).booleanValue()).booleanValue() && this.gears.functionCall(gr).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.gears.range().notElementOf(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_open_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && new BSet(new DOOR_STATE(enum_DOOR_STATE.closed), new DOOR_STATE(enum_DOOR_STATE.door_moving)).elementOf(this.door).booleanValue()).booleanValue() && this.gear.unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.retracted)).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.extended)).booleanValue()).booleanValue()).booleanValue())).booleanValue()) { + if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.isInDomain(gr).booleanValue() && this.doors.functionCall(gr).equal(new DOOR_STATE(enum_DOOR_STATE.closed)).booleanValue()).booleanValue() && this.gears.functionCall(gr).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.gears.isNotInRange(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_open_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && new BSet(new DOOR_STATE(enum_DOOR_STATE.closed), new DOOR_STATE(enum_DOOR_STATE.door_moving)).elementOf(this.door).booleanValue()).booleanValue() && this.gear.unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.retracted)).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.extended)).booleanValue()).booleanValue()).booleanValue())).booleanValue()) { let _ld_doors = this.doors; this.doors = _ld_doors.override(new BRelation(new BTuple(gr, new DOOR_STATE(enum_DOOR_STATE.door_moving)))); this.door = new DOOR_STATE(enum_DOOR_STATE.door_moving); @@ -484,7 +3118,7 @@ export default class LandingGear_R6 { } } env_open_door_last(gr) { - if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.domain().elementOf(gr).booleanValue() && this.doors.functionCall(gr).equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue()).booleanValue() && this.gears.functionCall(gr).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.gears.range().notElementOf(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.doors.relationImage(LandingGear_R6._POSITION.difference(new BSet(gr))).equal(new BSet(new DOOR_STATE(enum_DOOR_STATE.open))).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_open_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.door.equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue()).booleanValue() && this.gear.unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.retracted)).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.extended)).booleanValue()).booleanValue()).booleanValue())).booleanValue()) { + if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.isInDomain(gr).booleanValue() && this.doors.functionCall(gr).equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue()).booleanValue() && this.gears.functionCall(gr).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.gears.isNotInRange(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.doors.relationImage(LandingGear_R6._POSITION.difference(new BSet(gr))).equal(new BSet(new DOOR_STATE(enum_DOOR_STATE.open))).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_open_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.door.equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue()).booleanValue() && this.gear.unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.retracted)).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.extended)).booleanValue()).booleanValue()).booleanValue())).booleanValue()) { let _ld_doors = this.doors; this.doors = _ld_doors.override(new BRelation(new BTuple(gr, new DOOR_STATE(enum_DOOR_STATE.open)))); this.door = new DOOR_STATE(enum_DOOR_STATE.open); @@ -494,7 +3128,7 @@ export default class LandingGear_R6 { } } env_open_door_skip(gr) { - if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.domain().elementOf(gr).booleanValue() && this.doors.functionCall(gr).equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue()).booleanValue() && this.gears.functionCall(gr).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.gears.range().notElementOf(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.doors.relationImage(LandingGear_R6._POSITION.difference(new BSet(gr))).unequal(new BSet(new DOOR_STATE(enum_DOOR_STATE.open))).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_open_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue())).booleanValue()) { + if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.isInDomain(gr).booleanValue() && this.doors.functionCall(gr).equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue()).booleanValue() && this.gears.functionCall(gr).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.gears.isNotInRange(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.doors.relationImage(LandingGear_R6._POSITION.difference(new BSet(gr))).unequal(new BSet(new DOOR_STATE(enum_DOOR_STATE.open))).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_open_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue())).booleanValue()) { this.doors = this.doors.override(new BRelation(new BTuple(gr, new DOOR_STATE(enum_DOOR_STATE.open)))); } else { @@ -502,7 +3136,7 @@ export default class LandingGear_R6 { } } env_start_close_door(gr) { - if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.domain().elementOf(gr).booleanValue() && this.doors.functionCall(gr).equal(new DOOR_STATE(enum_DOOR_STATE.open)).booleanValue()).booleanValue() && this.gears.functionCall(gr).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && new BBoolean(this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue() || this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_close_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && new BSet(new DOOR_STATE(enum_DOOR_STATE.door_moving), new DOOR_STATE(enum_DOOR_STATE.open)).elementOf(this.door).booleanValue()).booleanValue() && this.gear.unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.extended)).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && new BSet(new GEAR_STATE(enum_GEAR_STATE.extended), new GEAR_STATE(enum_GEAR_STATE.retracted)).elementOf(this.gear).booleanValue()).booleanValue()).booleanValue())).booleanValue()) { + if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.isInDomain(gr).booleanValue() && this.doors.functionCall(gr).equal(new DOOR_STATE(enum_DOOR_STATE.open)).booleanValue()).booleanValue() && this.gears.functionCall(gr).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && new BBoolean(this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue() || this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_close_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && new BSet(new DOOR_STATE(enum_DOOR_STATE.door_moving), new DOOR_STATE(enum_DOOR_STATE.open)).elementOf(this.door).booleanValue()).booleanValue() && this.gear.unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.extended)).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && new BSet(new GEAR_STATE(enum_GEAR_STATE.extended), new GEAR_STATE(enum_GEAR_STATE.retracted)).elementOf(this.gear).booleanValue()).booleanValue()).booleanValue())).booleanValue()) { let _ld_doors = this.doors; this.doors = _ld_doors.override(new BRelation(new BTuple(gr, new DOOR_STATE(enum_DOOR_STATE.door_moving)))); this.door = new DOOR_STATE(enum_DOOR_STATE.door_moving); @@ -512,7 +3146,7 @@ export default class LandingGear_R6 { } } env_close_door(gr) { - if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.domain().elementOf(gr).booleanValue() && this.doors.functionCall(gr).equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue()).booleanValue() && this.gears.functionCall(gr).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.gears.range().notElementOf(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.doors.relationImage(LandingGear_R6._POSITION.difference(new BSet(gr))).equal(new BSet(new DOOR_STATE(enum_DOOR_STATE.closed))).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && new BBoolean(this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue() || this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_close_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && new BBoolean(!new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue() || this.shock_absorber.equal(new PLANE_STATE(enum_PLANE_STATE.ground)).booleanValue()).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.door.equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue()).booleanValue() && this.gear.unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.extended)).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && new BSet(new GEAR_STATE(enum_GEAR_STATE.extended), new GEAR_STATE(enum_GEAR_STATE.retracted)).elementOf(this.gear).booleanValue()).booleanValue()).booleanValue())).booleanValue()) { + if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.isInDomain(gr).booleanValue() && this.doors.functionCall(gr).equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue()).booleanValue() && this.gears.functionCall(gr).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.gears.isNotInRange(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.doors.relationImage(LandingGear_R6._POSITION.difference(new BSet(gr))).equal(new BSet(new DOOR_STATE(enum_DOOR_STATE.closed))).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && new BBoolean(this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue() || this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_close_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && new BBoolean(!new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue() || this.shock_absorber.equal(new PLANE_STATE(enum_PLANE_STATE.ground)).booleanValue()).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.door.equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue()).booleanValue() && this.gear.unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.extended)).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && new BSet(new GEAR_STATE(enum_GEAR_STATE.extended), new GEAR_STATE(enum_GEAR_STATE.retracted)).elementOf(this.gear).booleanValue()).booleanValue()).booleanValue())).booleanValue()) { let _ld_doors = this.doors; this.doors = _ld_doors.override(new BRelation(new BTuple(gr, new DOOR_STATE(enum_DOOR_STATE.closed)))); this.door = new DOOR_STATE(enum_DOOR_STATE.closed); @@ -522,7 +3156,7 @@ export default class LandingGear_R6 { } } env_close_door_skip(gr) { - if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.domain().elementOf(gr).booleanValue() && this.doors.functionCall(gr).equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue()).booleanValue() && this.gears.functionCall(gr).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.gears.range().notElementOf(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.doors.relationImage(LandingGear_R6._POSITION.difference(new BSet(gr))).unequal(new BSet(new DOOR_STATE(enum_DOOR_STATE.closed))).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && new BBoolean(this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue() || this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_close_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && new BBoolean(!new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue() || this.shock_absorber.equal(new PLANE_STATE(enum_PLANE_STATE.ground)).booleanValue()).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue())).booleanValue()) { + if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.gears.isInDomain(gr).booleanValue() && this.doors.functionCall(gr).equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue()).booleanValue() && this.gears.functionCall(gr).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.gears.isNotInRange(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.doors.relationImage(LandingGear_R6._POSITION.difference(new BSet(gr))).unequal(new BSet(new DOOR_STATE(enum_DOOR_STATE.closed))).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && new BBoolean(this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue() || this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_close_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && new BBoolean(!new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue() || this.shock_absorber.equal(new PLANE_STATE(enum_PLANE_STATE.ground)).booleanValue()).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue())).booleanValue()) { this.doors = this.doors.override(new BRelation(new BTuple(gr, new DOOR_STATE(enum_DOOR_STATE.closed)))); } else { @@ -668,9 +3302,66 @@ export default class LandingGear_R6 { _get__PLANE_STATE() { return LandingGear_R6._PLANE_STATE; } - _get__VALVE_STATE() { - return LandingGear_R6._VALVE_STATE; + _get__VALVE_STATE() { + return LandingGear_R6._VALVE_STATE; + } + equals(o) { + let o1 = this; + let o2 = o; + return o1._get_analogical_switch().equals(o2._get_analogical_switch()) && o1._get_general_EV().equals(o2._get_general_EV()) && o1._get_general_valve().equals(o2._get_general_valve()) && o1._get_handle_move().equals(o2._get_handle_move()) && o1._get_close_EV().equals(o2._get_close_EV()) && o1._get_extend_EV().equals(o2._get_extend_EV()) && o1._get_open_EV().equals(o2._get_open_EV()) && o1._get_retract_EV().equals(o2._get_retract_EV()) && o1._get_shock_absorber().equals(o2._get_shock_absorber()) && o1._get_valve_close_door().equals(o2._get_valve_close_door()) && o1._get_valve_extend_gear().equals(o2._get_valve_extend_gear()) && o1._get_valve_open_door().equals(o2._get_valve_open_door()) && o1._get_valve_retract_gear().equals(o2._get_valve_retract_gear()) && o1._get_doors().equals(o2._get_doors()) && o1._get_gears().equals(o2._get_gears()) && o1._get_handle().equals(o2._get_handle()) && o1._get_door().equals(o2._get_door()) && o1._get_gear().equals(o2._get_gear()); + } + hashCode() { + return this._hashCode_1(); + } + _hashCode_1() { + let result = 1; + result = (1543 * result) ^ ((this._get_analogical_switch()).hashCode() << 1); + result = (1543 * result) ^ ((this._get_general_EV()).hashCode() << 1); + result = (1543 * result) ^ ((this._get_general_valve()).hashCode() << 1); + result = (1543 * result) ^ ((this._get_handle_move()).hashCode() << 1); + result = (1543 * result) ^ ((this._get_close_EV()).hashCode() << 1); + result = (1543 * result) ^ ((this._get_extend_EV()).hashCode() << 1); + result = (1543 * result) ^ ((this._get_open_EV()).hashCode() << 1); + result = (1543 * result) ^ ((this._get_retract_EV()).hashCode() << 1); + result = (1543 * result) ^ ((this._get_shock_absorber()).hashCode() << 1); + result = (1543 * result) ^ ((this._get_valve_close_door()).hashCode() << 1); + result = (1543 * result) ^ ((this._get_valve_extend_gear()).hashCode() << 1); + result = (1543 * result) ^ ((this._get_valve_open_door()).hashCode() << 1); + result = (1543 * result) ^ ((this._get_valve_retract_gear()).hashCode() << 1); + result = (1543 * result) ^ ((this._get_doors()).hashCode() << 1); + result = (1543 * result) ^ ((this._get_gears()).hashCode() << 1); + result = (1543 * result) ^ ((this._get_handle()).hashCode() << 1); + result = (1543 * result) ^ ((this._get_door()).hashCode() << 1); + result = (1543 * result) ^ ((this._get_gear()).hashCode() << 1); + return result; + } + _hashCode_2() { + let result = 1; + result = (6151 * result) ^ ((this._get_analogical_switch()).hashCode() << 1); + result = (6151 * result) ^ ((this._get_general_EV()).hashCode() << 1); + result = (6151 * result) ^ ((this._get_general_valve()).hashCode() << 1); + result = (6151 * result) ^ ((this._get_handle_move()).hashCode() << 1); + result = (6151 * result) ^ ((this._get_close_EV()).hashCode() << 1); + result = (6151 * result) ^ ((this._get_extend_EV()).hashCode() << 1); + result = (6151 * result) ^ ((this._get_open_EV()).hashCode() << 1); + result = (6151 * result) ^ ((this._get_retract_EV()).hashCode() << 1); + result = (6151 * result) ^ ((this._get_shock_absorber()).hashCode() << 1); + result = (6151 * result) ^ ((this._get_valve_close_door()).hashCode() << 1); + result = (6151 * result) ^ ((this._get_valve_extend_gear()).hashCode() << 1); + result = (6151 * result) ^ ((this._get_valve_open_door()).hashCode() << 1); + result = (6151 * result) ^ ((this._get_valve_retract_gear()).hashCode() << 1); + result = (6151 * result) ^ ((this._get_doors()).hashCode() << 1); + result = (6151 * result) ^ ((this._get_gears()).hashCode() << 1); + result = (6151 * result) ^ ((this._get_handle()).hashCode() << 1); + result = (6151 * result) ^ ((this._get_door()).hashCode() << 1); + result = (6151 * result) ^ ((this._get_gear()).hashCode() << 1); + return result; + } + /* TODO + toString(): string { + return String.join("\n", "_get_analogical_switch: " + (this._get_analogical_switch()).toString(), "_get_general_EV: " + (this._get_general_EV()).toString(), "_get_general_valve: " + (this._get_general_valve()).toString(), "_get_handle_move: " + (this._get_handle_move()).toString(), "_get_close_EV: " + (this._get_close_EV()).toString(), "_get_extend_EV: " + (this._get_extend_EV()).toString(), "_get_open_EV: " + (this._get_open_EV()).toString(), "_get_retract_EV: " + (this._get_retract_EV()).toString(), "_get_shock_absorber: " + (this._get_shock_absorber()).toString(), "_get_valve_close_door: " + (this._get_valve_close_door()).toString(), "_get_valve_extend_gear: " + (this._get_valve_extend_gear()).toString(), "_get_valve_open_door: " + (this._get_valve_open_door()).toString(), "_get_valve_retract_gear: " + (this._get_valve_retract_gear()).toString(), "_get_doors: " + (this._get_doors()).toString(), "_get_gears: " + (this._get_gears()).toString(), "_get_handle: " + (this._get_handle()).toString(), "_get_door: " + (this._get_door()).toString(), "_get_gear: " + (this._get_gear()).toString()); } + */ _tr_begin_flying() { return this.shock_absorber.equal(new PLANE_STATE(enum_PLANE_STATE.ground)).booleanValue(); } @@ -782,7 +3473,7 @@ export default class LandingGear_R6 { _tr_env_start_open_door() { let _ic_set_24 = new BSet(); for (let _ic_gr_1 of this.gears.domain()) { - if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.doors.functionCall(_ic_gr_1).equal(new DOOR_STATE(enum_DOOR_STATE.closed)).booleanValue() && this.gears.functionCall(_ic_gr_1).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.gears.range().notElementOf(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_open_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && new BSet(new DOOR_STATE(enum_DOOR_STATE.closed), new DOOR_STATE(enum_DOOR_STATE.door_moving)).elementOf(this.door).booleanValue()).booleanValue() && this.gear.unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.retracted)).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.extended)).booleanValue()).booleanValue()).booleanValue())).booleanValue()) { + if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.doors.functionCall(_ic_gr_1).equal(new DOOR_STATE(enum_DOOR_STATE.closed)).booleanValue() && this.gears.functionCall(_ic_gr_1).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.gears.isNotInRange(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_open_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && new BSet(new DOOR_STATE(enum_DOOR_STATE.closed), new DOOR_STATE(enum_DOOR_STATE.door_moving)).elementOf(this.door).booleanValue()).booleanValue() && this.gear.unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.retracted)).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.extended)).booleanValue()).booleanValue()).booleanValue())).booleanValue()) { _ic_set_24 = _ic_set_24.union(new BSet(_ic_gr_1)); } } @@ -791,7 +3482,7 @@ export default class LandingGear_R6 { _tr_env_open_door_last() { let _ic_set_25 = new BSet(); for (let _ic_gr_1 of this.gears.domain()) { - if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.doors.functionCall(_ic_gr_1).equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue() && this.gears.functionCall(_ic_gr_1).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.gears.range().notElementOf(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.doors.relationImage(LandingGear_R6._POSITION.difference(new BSet(_ic_gr_1))).equal(new BSet(new DOOR_STATE(enum_DOOR_STATE.open))).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_open_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.door.equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue()).booleanValue() && this.gear.unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.retracted)).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.extended)).booleanValue()).booleanValue()).booleanValue())).booleanValue()) { + if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.doors.functionCall(_ic_gr_1).equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue() && this.gears.functionCall(_ic_gr_1).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.gears.isNotInRange(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.doors.relationImage(LandingGear_R6._POSITION.difference(new BSet(_ic_gr_1))).equal(new BSet(new DOOR_STATE(enum_DOOR_STATE.open))).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_open_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.door.equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue()).booleanValue() && this.gear.unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.retracted)).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.extended)).booleanValue()).booleanValue()).booleanValue())).booleanValue()) { _ic_set_25 = _ic_set_25.union(new BSet(_ic_gr_1)); } } @@ -800,7 +3491,7 @@ export default class LandingGear_R6 { _tr_env_open_door_skip() { let _ic_set_26 = new BSet(); for (let _ic_gr_1 of this.gears.domain()) { - if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.doors.functionCall(_ic_gr_1).equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue() && this.gears.functionCall(_ic_gr_1).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.gears.range().notElementOf(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.doors.relationImage(LandingGear_R6._POSITION.difference(new BSet(_ic_gr_1))).unequal(new BSet(new DOOR_STATE(enum_DOOR_STATE.open))).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_open_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue())).booleanValue()) { + if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.doors.functionCall(_ic_gr_1).equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue() && this.gears.functionCall(_ic_gr_1).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.gears.isNotInRange(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.doors.relationImage(LandingGear_R6._POSITION.difference(new BSet(_ic_gr_1))).unequal(new BSet(new DOOR_STATE(enum_DOOR_STATE.open))).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_open_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue())).booleanValue()) { _ic_set_26 = _ic_set_26.union(new BSet(_ic_gr_1)); } } @@ -818,7 +3509,7 @@ export default class LandingGear_R6 { _tr_env_close_door() { let _ic_set_28 = new BSet(); for (let _ic_gr_1 of this.gears.domain()) { - if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.doors.functionCall(_ic_gr_1).equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue() && this.gears.functionCall(_ic_gr_1).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.gears.range().notElementOf(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.doors.relationImage(LandingGear_R6._POSITION.difference(new BSet(_ic_gr_1))).equal(new BSet(new DOOR_STATE(enum_DOOR_STATE.closed))).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && new BBoolean(this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue() || this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_close_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && new BBoolean(!new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue() || this.shock_absorber.equal(new PLANE_STATE(enum_PLANE_STATE.ground)).booleanValue()).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.door.equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue()).booleanValue() && this.gear.unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.extended)).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && new BSet(new GEAR_STATE(enum_GEAR_STATE.extended), new GEAR_STATE(enum_GEAR_STATE.retracted)).elementOf(this.gear).booleanValue()).booleanValue()).booleanValue())).booleanValue()) { + if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.doors.functionCall(_ic_gr_1).equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue() && this.gears.functionCall(_ic_gr_1).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.gears.isNotInRange(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.doors.relationImage(LandingGear_R6._POSITION.difference(new BSet(_ic_gr_1))).equal(new BSet(new DOOR_STATE(enum_DOOR_STATE.closed))).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && new BBoolean(this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue() || this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_close_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && new BBoolean(!new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue() || this.shock_absorber.equal(new PLANE_STATE(enum_PLANE_STATE.ground)).booleanValue()).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && this.door.equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue()).booleanValue() && this.gear.unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.extended)).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && new BSet(new GEAR_STATE(enum_GEAR_STATE.extended), new GEAR_STATE(enum_GEAR_STATE.retracted)).elementOf(this.gear).booleanValue()).booleanValue()).booleanValue())).booleanValue()) { _ic_set_28 = _ic_set_28.union(new BSet(_ic_gr_1)); } } @@ -827,7 +3518,7 @@ export default class LandingGear_R6 { _tr_env_close_door_skip() { let _ic_set_29 = new BSet(); for (let _ic_gr_1 of this.gears.domain()) { - if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.doors.functionCall(_ic_gr_1).equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue() && this.gears.functionCall(_ic_gr_1).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.gears.range().notElementOf(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.doors.relationImage(LandingGear_R6._POSITION.difference(new BSet(_ic_gr_1))).unequal(new BSet(new DOOR_STATE(enum_DOOR_STATE.closed))).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && new BBoolean(this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue() || this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_close_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && new BBoolean(!new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue() || this.shock_absorber.equal(new PLANE_STATE(enum_PLANE_STATE.ground)).booleanValue()).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue())).booleanValue()) { + if ((new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(new BBoolean(this.doors.functionCall(_ic_gr_1).equal(new DOOR_STATE(enum_DOOR_STATE.door_moving)).booleanValue() && this.gears.functionCall(_ic_gr_1).unequal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.gears.isNotInRange(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue()).booleanValue() && this.doors.relationImage(LandingGear_R6._POSITION.difference(new BSet(_ic_gr_1))).unequal(new BSet(new DOOR_STATE(enum_DOOR_STATE.closed))).booleanValue()).booleanValue() && new BBoolean(new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && new BBoolean(this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.retracted))).booleanValue() || this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue() || new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.down)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue()).booleanValue()).booleanValue() && this.valve_close_door.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue()).booleanValue() && new BBoolean(!new BBoolean(this.handle.equal(new HANDLE_STATE(enum_HANDLE_STATE.up)).booleanValue() && this.gears.range().equal(new BSet(new GEAR_STATE(enum_GEAR_STATE.extended))).booleanValue()).booleanValue() || this.shock_absorber.equal(new PLANE_STATE(enum_PLANE_STATE.ground)).booleanValue()).booleanValue()).booleanValue() && this.general_valve.equal(new VALVE_STATE(enum_VALVE_STATE.valve_open)).booleanValue())).booleanValue()) { _ic_set_29 = _ic_set_29.union(new BSet(_ic_gr_1)); } } @@ -857,29 +3548,571 @@ export default class LandingGear_R6 { _tr_env_open_analogical_switch() { return this.analogical_switch.equal(new SWITCH_STATE(enum_SWITCH_STATE.switch_closed)).booleanValue(); } + _projected_state_for_close_valve_door_close() { + return new _ProjectionRead_close_valve_door_close(this.valve_close_door, this.close_EV); + } + _projected_state_for_close_valve_retract_gear() { + return new _ProjectionRead_close_valve_retract_gear(this.valve_retract_gear, this.retract_EV); + } + _projected_state_for_con_stimulate_open_door_valve() { + return new _ProjectionRead_con_stimulate_open_door_valve(this.handle, this.doors, this.open_EV, this.shock_absorber, this.close_EV, this.general_EV, this.gears); + } + _projected_state_for_env_close_door() { + return new _ProjectionRead_env_close_door(this.door, this.valve_close_door, this.handle, this.doors, this.shock_absorber, this.general_valve, this.gears, this.gear); + } + _projected_state_for_env_start_close_door() { + return new _ProjectionRead_env_start_close_door(this.door, this.valve_close_door, this.handle, this.doors, this.general_valve, this.gears, this.gear); + } + _projected_state_for_toggle_handle_up() { + return new _ProjectionRead_toggle_handle_up(this.handle); + } + _projected_state_for_toggle_handle_down() { + return new _ProjectionRead_toggle_handle_down(this.handle); + } + _projected_state_for_open_valve_door_open() { + return new _ProjectionRead_open_valve_door_open(this.valve_open_door, this.open_EV); + } + _projected_state_for_env_retract_gear_last() { + return new _ProjectionRead_env_retract_gear_last(this.door, this.handle, this.doors, this.general_valve, this.gears, this.gear); + } + _projected_state_for_env_open_door_last() { + return new _ProjectionRead_env_open_door_last(this.valve_open_door, this.door, this.handle, this.doors, this.general_valve, this.gears, this.gear); + } + _projected_state_for_con_stop_stimulate_retract_gear_valve() { + return new _ProjectionRead_con_stop_stimulate_retract_gear_valve(this.handle, this.general_EV, this.retract_EV, this.gears); + } + _projected_state_for_env_close_door_skip() { + return new _ProjectionRead_env_close_door_skip(this.valve_close_door, this.handle, this.doors, this.shock_absorber, this.general_valve, this.gears); + } + _projected_state_for_con_stop_stimulate_close_door_valve() { + return new _ProjectionRead_con_stop_stimulate_close_door_valve(this.doors, this.shock_absorber, this.handle, this.close_EV, this.general_EV, this.gears); + } + _projected_state_for_env_open_analogical_switch() { + return new _ProjectionRead_env_open_analogical_switch(this.analogical_switch); + } + _projected_state_for_con_stop_stimulate_general_valve() { + return new _ProjectionRead_con_stop_stimulate_general_valve(this.extend_EV, this.handle, this.doors, this.open_EV, this.close_EV, this.general_EV, this.retract_EV, this.gears); + } + _projected_state_for_env_extend_gear_last() { + return new _ProjectionRead_env_extend_gear_last(this.door, this.handle, this.doors, this.general_valve, this.gears, this.gear); + } + _projected_state_for_evn_open_general_valve() { + return new _ProjectionRead_evn_open_general_valve(this.general_valve, this.analogical_switch, this.general_EV); + } + _projected_state_for_land_plane() { + return new _ProjectionRead_land_plane(this.shock_absorber); + } + _projected_state_for_con_stimulate_retract_gear_valve() { + return new _ProjectionRead_con_stimulate_retract_gear_valve(this.extend_EV, this.doors, this.open_EV, this.shock_absorber, this.handle, this.general_EV, this.retract_EV, this.gears); + } + _projected_state_for_con_stimulate_general_valve() { + return new _ProjectionRead_con_stimulate_general_valve(this.handle_move, this.general_EV); + } + _projected_state_for_env_start_retracting_first() { + return new _ProjectionRead_env_start_retracting_first(this.door, this.handle, this.valve_retract_gear, this.doors, this.general_valve, this.gears, this.gear); + } + _projected_state_for_env_retract_gear_skip() { + return new _ProjectionRead_env_retract_gear_skip(this.doors, this.general_valve, this.handle, this.gears); + } + _projected_state_for_open_valve_extend_gear() { + return new _ProjectionRead_open_valve_extend_gear(this.extend_EV, this.valve_extend_gear); + } + _projected_state_for_begin_flying() { + return new _ProjectionRead_begin_flying(this.shock_absorber); + } + _projected_state_for_open_valve_retract_gear() { + return new _ProjectionRead_open_valve_retract_gear(this.valve_retract_gear, this.retract_EV); + } + _projected_state_for_env_close_analogical_switch() { + return new _ProjectionRead_env_close_analogical_switch(this.analogical_switch, this.handle_move); + } + _projected_state_for_env_start_extending() { + return new _ProjectionRead_env_start_extending(this.door, this.handle, this.doors, this.general_valve, this.valve_extend_gear, this.gears, this.gear); + } + _projected_state_for_open_valve_door_close() { + return new _ProjectionRead_open_valve_door_close(this.valve_close_door, this.close_EV); + } + _projected_state_for_con_stop_stimulate_open_door_valve() { + return new _ProjectionRead_con_stop_stimulate_open_door_valve(this.extend_EV, this.handle, this.doors, this.open_EV, this.shock_absorber, this.general_EV, this.retract_EV, this.gears); + } + _projected_state_for_con_stop_stimulate_extend_gear_valve() { + return new _ProjectionRead_con_stop_stimulate_extend_gear_valve(this.extend_EV, this.handle, this.general_EV, this.gears); + } + _projected_state_for_evn_close_general_valve() { + return new _ProjectionRead_evn_close_general_valve(this.general_valve, this.analogical_switch, this.general_EV); + } + _projected_state_for_close_valve_extend_gear() { + return new _ProjectionRead_close_valve_extend_gear(this.extend_EV, this.valve_extend_gear); + } + _projected_state_for_con_stimulate_extend_gear_valve() { + return new _ProjectionRead_con_stimulate_extend_gear_valve(this.extend_EV, this.doors, this.open_EV, this.handle, this.general_EV, this.retract_EV, this.gears); + } + _projected_state_for_close_valve_door_open() { + return new _ProjectionRead_close_valve_door_open(this.valve_open_door, this.open_EV); + } + _projected_state_for_con_stimulate_close_door_valve() { + return new _ProjectionRead_con_stimulate_close_door_valve(this.extend_EV, this.handle, this.doors, this.open_EV, this.shock_absorber, this.close_EV, this.general_EV, this.retract_EV, this.gears); + } + _projected_state_for_env_extend_gear_skip() { + return new _ProjectionRead_env_extend_gear_skip(this.doors, this.general_valve, this.handle, this.gears); + } + _projected_state_for_env_open_door_skip() { + return new _ProjectionRead_env_open_door_skip(this.valve_open_door, this.handle, this.doors, this.general_valve, this.gears); + } + _projected_state_for_env_start_open_door() { + return new _ProjectionRead_env_start_open_door(this.valve_open_door, this.door, this.handle, this.doors, this.general_valve, this.gears, this.gear); + } + _projected_state_for__tr_env_retract_gear_last() { + return new _ProjectionRead__tr_env_retract_gear_last(this.door, this.handle, this.doors, this.general_valve, this.gears, this.gear); + } + _projected_state_for__tr_open_valve_door_open() { + return new _ProjectionRead__tr_open_valve_door_open(this.valve_open_door, this.open_EV); + } + _projected_state_for__tr_env_open_analogical_switch() { + return new _ProjectionRead__tr_env_open_analogical_switch(this.analogical_switch); + } + _projected_state_for__tr_con_stimulate_extend_gear_valve() { + return new _ProjectionRead__tr_con_stimulate_extend_gear_valve(this.extend_EV, this.doors, this.open_EV, this.handle, this.general_EV, this.retract_EV, this.gears); + } + _projected_state_for__tr_env_close_door_skip() { + return new _ProjectionRead__tr_env_close_door_skip(this.valve_close_door, this.handle, this.doors, this.shock_absorber, this.general_valve, this.gears); + } + _projected_state_for__tr_con_stop_stimulate_open_door_valve() { + return new _ProjectionRead__tr_con_stop_stimulate_open_door_valve(this.extend_EV, this.handle, this.doors, this.open_EV, this.shock_absorber, this.general_EV, this.retract_EV, this.gears); + } + _projected_state_for__tr_con_stimulate_close_door_valve() { + return new _ProjectionRead__tr_con_stimulate_close_door_valve(this.extend_EV, this.handle, this.doors, this.open_EV, this.shock_absorber, this.close_EV, this.general_EV, this.retract_EV, this.gears); + } + _projected_state_for__tr_env_close_analogical_switch() { + return new _ProjectionRead__tr_env_close_analogical_switch(this.analogical_switch, this.handle_move); + } + _projected_state_for__tr_evn_close_general_valve() { + return new _ProjectionRead__tr_evn_close_general_valve(this.general_valve, this.analogical_switch, this.general_EV); + } + _projected_state_for__tr_con_stop_stimulate_retract_gear_valve() { + return new _ProjectionRead__tr_con_stop_stimulate_retract_gear_valve(this.handle, this.general_EV, this.retract_EV, this.gears); + } + _projected_state_for__tr_land_plane() { + return new _ProjectionRead__tr_land_plane(this.shock_absorber); + } + _projected_state_for__tr_open_valve_door_close() { + return new _ProjectionRead__tr_open_valve_door_close(this.valve_close_door, this.close_EV); + } + _projected_state_for__tr_con_stop_stimulate_general_valve() { + return new _ProjectionRead__tr_con_stop_stimulate_general_valve(this.extend_EV, this.handle, this.doors, this.open_EV, this.close_EV, this.general_EV, this.retract_EV, this.gears); + } + _projected_state_for__tr_con_stimulate_open_door_valve() { + return new _ProjectionRead__tr_con_stimulate_open_door_valve(this.handle, this.doors, this.open_EV, this.shock_absorber, this.close_EV, this.general_EV, this.gears); + } + _projected_state_for__tr_env_start_extending() { + return new _ProjectionRead__tr_env_start_extending(this.door, this.handle, this.doors, this.general_valve, this.valve_extend_gear, this.gears, this.gear); + } + _projected_state_for__tr_env_extend_gear_last() { + return new _ProjectionRead__tr_env_extend_gear_last(this.door, this.handle, this.doors, this.general_valve, this.gears, this.gear); + } + _projected_state_for__tr_env_open_door_skip() { + return new _ProjectionRead__tr_env_open_door_skip(this.valve_open_door, this.handle, this.doors, this.general_valve, this.gears); + } + _projected_state_for__tr_close_valve_retract_gear() { + return new _ProjectionRead__tr_close_valve_retract_gear(this.valve_retract_gear, this.retract_EV); + } + _projected_state_for__tr_close_valve_extend_gear() { + return new _ProjectionRead__tr_close_valve_extend_gear(this.extend_EV, this.valve_extend_gear); + } + _projected_state_for__tr_con_stimulate_general_valve() { + return new _ProjectionRead__tr_con_stimulate_general_valve(this.handle_move, this.general_EV); + } + _projected_state_for__tr_open_valve_extend_gear() { + return new _ProjectionRead__tr_open_valve_extend_gear(this.extend_EV, this.valve_extend_gear); + } + _projected_state_for__tr_con_stimulate_retract_gear_valve() { + return new _ProjectionRead__tr_con_stimulate_retract_gear_valve(this.extend_EV, this.doors, this.open_EV, this.shock_absorber, this.handle, this.general_EV, this.retract_EV, this.gears); + } + _projected_state_for__tr_evn_open_general_valve() { + return new _ProjectionRead__tr_evn_open_general_valve(this.general_valve, this.analogical_switch, this.general_EV); + } + _projected_state_for__tr_env_retract_gear_skip() { + return new _ProjectionRead__tr_env_retract_gear_skip(this.doors, this.general_valve, this.handle, this.gears); + } + _projected_state_for__tr_env_start_open_door() { + return new _ProjectionRead__tr_env_start_open_door(this.valve_open_door, this.door, this.handle, this.doors, this.general_valve, this.gears, this.gear); + } + _projected_state_for__tr_env_close_door() { + return new _ProjectionRead__tr_env_close_door(this.door, this.valve_close_door, this.handle, this.doors, this.shock_absorber, this.general_valve, this.gears, this.gear); + } + _projected_state_for__tr_con_stop_stimulate_extend_gear_valve() { + return new _ProjectionRead__tr_con_stop_stimulate_extend_gear_valve(this.extend_EV, this.handle, this.general_EV, this.gears); + } + _projected_state_for__tr_close_valve_door_open() { + return new _ProjectionRead__tr_close_valve_door_open(this.valve_open_door, this.open_EV); + } + _projected_state_for__tr_env_start_retracting_first() { + return new _ProjectionRead__tr_env_start_retracting_first(this.door, this.handle, this.valve_retract_gear, this.doors, this.general_valve, this.gears, this.gear); + } + _projected_state_for__tr_env_extend_gear_skip() { + return new _ProjectionRead__tr_env_extend_gear_skip(this.doors, this.general_valve, this.handle, this.gears); + } + _projected_state_for__tr_toggle_handle_down() { + return new _ProjectionRead__tr_toggle_handle_down(this.handle); + } + _projected_state_for__tr_begin_flying() { + return new _ProjectionRead__tr_begin_flying(this.shock_absorber); + } + _projected_state_for__tr_open_valve_retract_gear() { + return new _ProjectionRead__tr_open_valve_retract_gear(this.valve_retract_gear, this.retract_EV); + } + _projected_state_for__tr_env_open_door_last() { + return new _ProjectionRead__tr_env_open_door_last(this.valve_open_door, this.door, this.handle, this.doors, this.general_valve, this.gears, this.gear); + } + _projected_state_for__tr_toggle_handle_up() { + return new _ProjectionRead__tr_toggle_handle_up(this.handle); + } + _projected_state_for__tr_env_start_close_door() { + return new _ProjectionRead__tr_env_start_close_door(this.door, this.valve_close_door, this.handle, this.doors, this.general_valve, this.gears, this.gear); + } + _projected_state_for__tr_con_stop_stimulate_close_door_valve() { + return new _ProjectionRead__tr_con_stop_stimulate_close_door_valve(this.doors, this.shock_absorber, this.handle, this.close_EV, this.general_EV, this.gears); + } + _projected_state_for__tr_close_valve_door_close() { + return new _ProjectionRead__tr_close_valve_door_close(this.valve_close_door, this.close_EV); + } + _projected_state_for__check_inv_18() { + return new _ProjectionRead__check_inv_18(this.open_EV, this.close_EV); + } + _projected_state_for__check_inv_17() { + return new _ProjectionRead__check_inv_17(this.extend_EV, this.open_EV, this.close_EV, this.general_EV, this.retract_EV); + } + _projected_state_for__check_inv_16() { + return new _ProjectionRead__check_inv_16(this.gear); + } + _projected_state_for__check_inv_15() { + return new _ProjectionRead__check_inv_15(this.door); + } + _projected_state_for__check_inv_19() { + return new _ProjectionRead__check_inv_19(this.gears); + } + _projected_state_for__check_inv_10() { + return new _ProjectionRead__check_inv_10(this.valve_close_door); + } + _projected_state_for__check_inv_14() { + return new _ProjectionRead__check_inv_14(this.handle); + } + _projected_state_for__check_inv_13() { + return new _ProjectionRead__check_inv_13(this.valve_retract_gear); + } + _projected_state_for__check_inv_12() { + return new _ProjectionRead__check_inv_12(this.valve_open_door); + } + _projected_state_for__check_inv_11() { + return new _ProjectionRead__check_inv_11(this.valve_extend_gear); + } + _projected_state_for__check_inv_6() { + return new _ProjectionRead__check_inv_6(this.extend_EV); + } + _projected_state_for__check_inv_21() { + return new _ProjectionRead__check_inv_21(this.doors, this.door); + } + _projected_state_for__check_inv_7() { + return new _ProjectionRead__check_inv_7(this.open_EV); + } + _projected_state_for__check_inv_20() { + return new _ProjectionRead__check_inv_20(this.doors); + } + _projected_state_for__check_inv_4() { + return new _ProjectionRead__check_inv_4(this.handle_move); + } + _projected_state_for__check_inv_5() { + return new _ProjectionRead__check_inv_5(this.close_EV); + } + _projected_state_for__check_inv_25() { + return new _ProjectionRead__check_inv_25(this.door, this.gear); + } + _projected_state_for__check_inv_24() { + return new _ProjectionRead__check_inv_24(this.gears, this.gear); + } + _projected_state_for__check_inv_8() { + return new _ProjectionRead__check_inv_8(this.retract_EV); + } + _projected_state_for__check_inv_23() { + return new _ProjectionRead__check_inv_23(this.gears, this.gear); + } + _projected_state_for__check_inv_9() { + return new _ProjectionRead__check_inv_9(this.shock_absorber); + } + _projected_state_for__check_inv_22() { + return new _ProjectionRead__check_inv_22(this.doors, this.door); + } + _projected_state_for__check_inv_2() { + return new _ProjectionRead__check_inv_2(this.general_EV); + } + _projected_state_for__check_inv_3() { + return new _ProjectionRead__check_inv_3(this.general_valve); + } + _projected_state_for__check_inv_1() { + return new _ProjectionRead__check_inv_1(this.analogical_switch); + } + _update_for_close_valve_door_close() { + return new _ProjectionWrite_close_valve_door_close(this.valve_close_door); + } + _update_for_close_valve_retract_gear() { + return new _ProjectionWrite_close_valve_retract_gear(this.valve_retract_gear); + } + _update_for_con_stimulate_open_door_valve() { + return new _ProjectionWrite_con_stimulate_open_door_valve(this.open_EV); + } + _update_for_env_close_door() { + return new _ProjectionWrite_env_close_door(this.doors, this.door); + } + _update_for_env_start_close_door() { + return new _ProjectionWrite_env_start_close_door(this.doors, this.door); + } + _update_for_toggle_handle_up() { + return new _ProjectionWrite_toggle_handle_up(this.handle, this.handle_move); + } + _update_for_toggle_handle_down() { + return new _ProjectionWrite_toggle_handle_down(this.handle, this.handle_move); + } + _update_for_open_valve_door_open() { + return new _ProjectionWrite_open_valve_door_open(this.valve_open_door); + } + _update_for_env_retract_gear_last() { + return new _ProjectionWrite_env_retract_gear_last(this.gears, this.gear); + } + _update_for_env_open_door_last() { + return new _ProjectionWrite_env_open_door_last(this.doors, this.door); + } + _update_for_con_stop_stimulate_retract_gear_valve() { + return new _ProjectionWrite_con_stop_stimulate_retract_gear_valve(this.retract_EV); + } + _update_for_env_close_door_skip() { + return new _ProjectionWrite_env_close_door_skip(this.doors); + } + _update_for_con_stop_stimulate_close_door_valve() { + return new _ProjectionWrite_con_stop_stimulate_close_door_valve(this.close_EV); + } + _update_for_env_open_analogical_switch() { + return new _ProjectionWrite_env_open_analogical_switch(this.analogical_switch); + } + _update_for_con_stop_stimulate_general_valve() { + return new _ProjectionWrite_con_stop_stimulate_general_valve(this.handle_move, this.general_EV); + } + _update_for_env_extend_gear_last() { + return new _ProjectionWrite_env_extend_gear_last(this.gears, this.gear); + } + _update_for_evn_open_general_valve() { + return new _ProjectionWrite_evn_open_general_valve(this.general_valve); + } + _update_for_land_plane() { + return new _ProjectionWrite_land_plane(this.shock_absorber); + } + _update_for_con_stimulate_retract_gear_valve() { + return new _ProjectionWrite_con_stimulate_retract_gear_valve(this.retract_EV); + } + _update_for_con_stimulate_general_valve() { + return new _ProjectionWrite_con_stimulate_general_valve(this.general_EV); + } + _update_for_env_start_retracting_first() { + return new _ProjectionWrite_env_start_retracting_first(this.gears, this.gear); + } + _update_for_env_retract_gear_skip() { + return new _ProjectionWrite_env_retract_gear_skip(this.gears); + } + _update_for_open_valve_extend_gear() { + return new _ProjectionWrite_open_valve_extend_gear(this.valve_extend_gear); + } + _update_for_begin_flying() { + return new _ProjectionWrite_begin_flying(this.shock_absorber); + } + _update_for_open_valve_retract_gear() { + return new _ProjectionWrite_open_valve_retract_gear(this.valve_retract_gear); + } + _update_for_env_close_analogical_switch() { + return new _ProjectionWrite_env_close_analogical_switch(this.analogical_switch); + } + _update_for_env_start_extending() { + return new _ProjectionWrite_env_start_extending(this.gears, this.gear); + } + _update_for_open_valve_door_close() { + return new _ProjectionWrite_open_valve_door_close(this.valve_close_door); + } + _update_for_con_stop_stimulate_open_door_valve() { + return new _ProjectionWrite_con_stop_stimulate_open_door_valve(this.open_EV); + } + _update_for_con_stop_stimulate_extend_gear_valve() { + return new _ProjectionWrite_con_stop_stimulate_extend_gear_valve(this.extend_EV); + } + _update_for_evn_close_general_valve() { + return new _ProjectionWrite_evn_close_general_valve(this.general_valve); + } + _update_for_close_valve_extend_gear() { + return new _ProjectionWrite_close_valve_extend_gear(this.valve_extend_gear); + } + _update_for_con_stimulate_extend_gear_valve() { + return new _ProjectionWrite_con_stimulate_extend_gear_valve(this.extend_EV); + } + _update_for_close_valve_door_open() { + return new _ProjectionWrite_close_valve_door_open(this.valve_open_door); + } + _update_for_con_stimulate_close_door_valve() { + return new _ProjectionWrite_con_stimulate_close_door_valve(this.close_EV); + } + _update_for_env_extend_gear_skip() { + return new _ProjectionWrite_env_extend_gear_skip(this.gears); + } + _update_for_env_open_door_skip() { + return new _ProjectionWrite_env_open_door_skip(this.doors); + } + _update_for_env_start_open_door() { + return new _ProjectionWrite_env_start_open_door(this.doors, this.door); + } + _apply_update_for_close_valve_door_close(update) { + this.valve_close_door = update.valve_close_door; + } + _apply_update_for_close_valve_retract_gear(update) { + this.valve_retract_gear = update.valve_retract_gear; + } + _apply_update_for_con_stimulate_open_door_valve(update) { + this.open_EV = update.open_EV; + } + _apply_update_for_env_close_door(update) { + this.doors = update.doors; + this.door = update.door; + } + _apply_update_for_env_start_close_door(update) { + this.doors = update.doors; + this.door = update.door; + } + _apply_update_for_toggle_handle_up(update) { + this.handle = update.handle; + this.handle_move = update.handle_move; + } + _apply_update_for_toggle_handle_down(update) { + this.handle = update.handle; + this.handle_move = update.handle_move; + } + _apply_update_for_open_valve_door_open(update) { + this.valve_open_door = update.valve_open_door; + } + _apply_update_for_env_retract_gear_last(update) { + this.gears = update.gears; + this.gear = update.gear; + } + _apply_update_for_env_open_door_last(update) { + this.doors = update.doors; + this.door = update.door; + } + _apply_update_for_con_stop_stimulate_retract_gear_valve(update) { + this.retract_EV = update.retract_EV; + } + _apply_update_for_env_close_door_skip(update) { + this.doors = update.doors; + } + _apply_update_for_con_stop_stimulate_close_door_valve(update) { + this.close_EV = update.close_EV; + } + _apply_update_for_env_open_analogical_switch(update) { + this.analogical_switch = update.analogical_switch; + } + _apply_update_for_con_stop_stimulate_general_valve(update) { + this.handle_move = update.handle_move; + this.general_EV = update.general_EV; + } + _apply_update_for_env_extend_gear_last(update) { + this.gears = update.gears; + this.gear = update.gear; + } + _apply_update_for_evn_open_general_valve(update) { + this.general_valve = update.general_valve; + } + _apply_update_for_land_plane(update) { + this.shock_absorber = update.shock_absorber; + } + _apply_update_for_con_stimulate_retract_gear_valve(update) { + this.retract_EV = update.retract_EV; + } + _apply_update_for_con_stimulate_general_valve(update) { + this.general_EV = update.general_EV; + } + _apply_update_for_env_start_retracting_first(update) { + this.gears = update.gears; + this.gear = update.gear; + } + _apply_update_for_env_retract_gear_skip(update) { + this.gears = update.gears; + } + _apply_update_for_open_valve_extend_gear(update) { + this.valve_extend_gear = update.valve_extend_gear; + } + _apply_update_for_begin_flying(update) { + this.shock_absorber = update.shock_absorber; + } + _apply_update_for_open_valve_retract_gear(update) { + this.valve_retract_gear = update.valve_retract_gear; + } + _apply_update_for_env_close_analogical_switch(update) { + this.analogical_switch = update.analogical_switch; + } + _apply_update_for_env_start_extending(update) { + this.gears = update.gears; + this.gear = update.gear; + } + _apply_update_for_open_valve_door_close(update) { + this.valve_close_door = update.valve_close_door; + } + _apply_update_for_con_stop_stimulate_open_door_valve(update) { + this.open_EV = update.open_EV; + } + _apply_update_for_con_stop_stimulate_extend_gear_valve(update) { + this.extend_EV = update.extend_EV; + } + _apply_update_for_evn_close_general_valve(update) { + this.general_valve = update.general_valve; + } + _apply_update_for_close_valve_extend_gear(update) { + this.valve_extend_gear = update.valve_extend_gear; + } + _apply_update_for_con_stimulate_extend_gear_valve(update) { + this.extend_EV = update.extend_EV; + } + _apply_update_for_close_valve_door_open(update) { + this.valve_open_door = update.valve_open_door; + } + _apply_update_for_con_stimulate_close_door_valve(update) { + this.close_EV = update.close_EV; + } + _apply_update_for_env_extend_gear_skip(update) { + this.gears = update.gears; + } + _apply_update_for_env_open_door_skip(update) { + this.doors = update.doors; + } + _apply_update_for_env_start_open_door(update) { + this.doors = update.doors; + this.door = update.door; + } _check_inv_1() { return LandingGear_R6._SWITCH_STATE.elementOf(this.analogical_switch).booleanValue(); } _check_inv_2() { - return BUtils.BOOL.elementOf(this.general_EV).booleanValue(); + return this.general_EV.isBoolean().booleanValue(); } _check_inv_3() { return LandingGear_R6._VALVE_STATE.elementOf(this.general_valve).booleanValue(); } _check_inv_4() { - return BUtils.BOOL.elementOf(this.handle_move).booleanValue(); + return this.handle_move.isBoolean().booleanValue(); } _check_inv_5() { - return BUtils.BOOL.elementOf(this.close_EV).booleanValue(); + return this.close_EV.isBoolean().booleanValue(); } _check_inv_6() { - return BUtils.BOOL.elementOf(this.extend_EV).booleanValue(); + return this.extend_EV.isBoolean().booleanValue(); } _check_inv_7() { - return BUtils.BOOL.elementOf(this.open_EV).booleanValue(); + return this.open_EV.isBoolean().booleanValue(); } _check_inv_8() { - return BUtils.BOOL.elementOf(this.retract_EV).booleanValue(); + return this.retract_EV.isBoolean().booleanValue(); } _check_inv_9() { return LandingGear_R6._PLANE_STATE.elementOf(this.shock_absorber).booleanValue(); @@ -932,63 +4165,6 @@ export default class LandingGear_R6 { _check_inv_25() { return new BBoolean(!this.gear.equal(new GEAR_STATE(enum_GEAR_STATE.gear_moving)).booleanValue() || this.door.equal(new DOOR_STATE(enum_DOOR_STATE.open)).booleanValue()).booleanValue(); } - equals(o) { - let o1 = this; - let o2 = o; - return o1._get_analogical_switch().equals(o2._get_analogical_switch()) && o1._get_general_EV().equals(o2._get_general_EV()) && o1._get_general_valve().equals(o2._get_general_valve()) && o1._get_handle_move().equals(o2._get_handle_move()) && o1._get_close_EV().equals(o2._get_close_EV()) && o1._get_extend_EV().equals(o2._get_extend_EV()) && o1._get_open_EV().equals(o2._get_open_EV()) && o1._get_retract_EV().equals(o2._get_retract_EV()) && o1._get_shock_absorber().equals(o2._get_shock_absorber()) && o1._get_valve_close_door().equals(o2._get_valve_close_door()) && o1._get_valve_extend_gear().equals(o2._get_valve_extend_gear()) && o1._get_valve_open_door().equals(o2._get_valve_open_door()) && o1._get_valve_retract_gear().equals(o2._get_valve_retract_gear()) && o1._get_doors().equals(o2._get_doors()) && o1._get_gears().equals(o2._get_gears()) && o1._get_handle().equals(o2._get_handle()) && o1._get_door().equals(o2._get_door()) && o1._get_gear().equals(o2._get_gear()); - } - hashCode() { - return this._hashCode_1(); - } - _hashCode_1() { - let result = 1; - result = (1543 * result) ^ ((this._get_analogical_switch()).hashCode() << 1); - result = (1543 * result) ^ ((this._get_general_EV()).hashCode() << 1); - result = (1543 * result) ^ ((this._get_general_valve()).hashCode() << 1); - result = (1543 * result) ^ ((this._get_handle_move()).hashCode() << 1); - result = (1543 * result) ^ ((this._get_close_EV()).hashCode() << 1); - result = (1543 * result) ^ ((this._get_extend_EV()).hashCode() << 1); - result = (1543 * result) ^ ((this._get_open_EV()).hashCode() << 1); - result = (1543 * result) ^ ((this._get_retract_EV()).hashCode() << 1); - result = (1543 * result) ^ ((this._get_shock_absorber()).hashCode() << 1); - result = (1543 * result) ^ ((this._get_valve_close_door()).hashCode() << 1); - result = (1543 * result) ^ ((this._get_valve_extend_gear()).hashCode() << 1); - result = (1543 * result) ^ ((this._get_valve_open_door()).hashCode() << 1); - result = (1543 * result) ^ ((this._get_valve_retract_gear()).hashCode() << 1); - result = (1543 * result) ^ ((this._get_doors()).hashCode() << 1); - result = (1543 * result) ^ ((this._get_gears()).hashCode() << 1); - result = (1543 * result) ^ ((this._get_handle()).hashCode() << 1); - result = (1543 * result) ^ ((this._get_door()).hashCode() << 1); - result = (1543 * result) ^ ((this._get_gear()).hashCode() << 1); - return result; - } - _hashCode_2() { - let result = 1; - result = (6151 * result) ^ ((this._get_analogical_switch()).hashCode() << 1); - result = (6151 * result) ^ ((this._get_general_EV()).hashCode() << 1); - result = (6151 * result) ^ ((this._get_general_valve()).hashCode() << 1); - result = (6151 * result) ^ ((this._get_handle_move()).hashCode() << 1); - result = (6151 * result) ^ ((this._get_close_EV()).hashCode() << 1); - result = (6151 * result) ^ ((this._get_extend_EV()).hashCode() << 1); - result = (6151 * result) ^ ((this._get_open_EV()).hashCode() << 1); - result = (6151 * result) ^ ((this._get_retract_EV()).hashCode() << 1); - result = (6151 * result) ^ ((this._get_shock_absorber()).hashCode() << 1); - result = (6151 * result) ^ ((this._get_valve_close_door()).hashCode() << 1); - result = (6151 * result) ^ ((this._get_valve_extend_gear()).hashCode() << 1); - result = (6151 * result) ^ ((this._get_valve_open_door()).hashCode() << 1); - result = (6151 * result) ^ ((this._get_valve_retract_gear()).hashCode() << 1); - result = (6151 * result) ^ ((this._get_doors()).hashCode() << 1); - result = (6151 * result) ^ ((this._get_gears()).hashCode() << 1); - result = (6151 * result) ^ ((this._get_handle()).hashCode() << 1); - result = (6151 * result) ^ ((this._get_door()).hashCode() << 1); - result = (6151 * result) ^ ((this._get_gear()).hashCode() << 1); - return result; - } - /* TODO - toString(): string { - return String.join("\n", "_get_analogical_switch: " + (this._get_analogical_switch()).toString(), "_get_general_EV: " + (this._get_general_EV()).toString(), "_get_general_valve: " + (this._get_general_valve()).toString(), "_get_handle_move: " + (this._get_handle_move()).toString(), "_get_close_EV: " + (this._get_close_EV()).toString(), "_get_extend_EV: " + (this._get_extend_EV()).toString(), "_get_open_EV: " + (this._get_open_EV()).toString(), "_get_retract_EV: " + (this._get_retract_EV()).toString(), "_get_shock_absorber: " + (this._get_shock_absorber()).toString(), "_get_valve_close_door: " + (this._get_valve_close_door()).toString(), "_get_valve_extend_gear: " + (this._get_valve_extend_gear()).toString(), "_get_valve_open_door: " + (this._get_valve_open_door()).toString(), "_get_valve_retract_gear: " + (this._get_valve_retract_gear()).toString(), "_get_doors: " + (this._get_doors()).toString(), "_get_gears: " + (this._get_gears()).toString(), "_get_handle: " + (this._get_handle()).toString(), "_get_door: " + (this._get_door()).toString(), "_get_gear: " + (this._get_gear()).toString()); - } - */ _copy() { return new LandingGear_R6(this); } diff --git a/visualizations/LandingGear/HydraulicCircuit/btypes/BBoolean.js b/visualizations/LandingGear/HydraulicCircuit/btypes/BBoolean.js old mode 100755 new mode 100644 index 130448faa26383f85f2db7a048581e0778fdb1d5..d1532a2d847adaa706b902563389afb75e3b5051 --- a/visualizations/LandingGear/HydraulicCircuit/btypes/BBoolean.js +++ b/visualizations/LandingGear/HydraulicCircuit/btypes/BBoolean.js @@ -37,6 +37,12 @@ export class BBoolean { unequal(other) { return new BBoolean(this.value != other.value); } + isBoolean() { + return new BBoolean(true); + } + isNotBoolean() { + return new BBoolean(false); + } booleanValue() { return this.value; } @@ -44,6 +50,6 @@ export class BBoolean { return this.value.toString(); } hashCode() { - return this.value ? 1 : 0; + return (31 * 1) ^ (this.value == true ? 1 : 0 << 1); } } diff --git a/visualizations/LandingGear/HydraulicCircuit/btypes/BInteger.js b/visualizations/LandingGear/HydraulicCircuit/btypes/BInteger.js old mode 100755 new mode 100644 index ee89703caf8374f626677d748673953dbc0814ec..dab6c9a89dbc5e21032a022e625c99124d8c0b7b --- a/visualizations/LandingGear/HydraulicCircuit/btypes/BInteger.js +++ b/visualizations/LandingGear/HydraulicCircuit/btypes/BInteger.js @@ -1,4 +1,4 @@ -import { BBoolean } from 'https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BBoolean.js'; +import { BBoolean } from './BBoolean.js'; export class BInteger { constructor(value) { this.value = value; @@ -16,22 +16,22 @@ export class BInteger { return this.value - o.value; } lessEqual(o) { - return new BBoolean(this.compareTo(o) <= 0); + return new BBoolean(this.value <= o.value); } greaterEqual(o) { - return new BBoolean(this.compareTo(o) >= 0); + return new BBoolean(this.value >= o.value); } less(o) { - return new BBoolean(this.compareTo(o) < 0); + return new BBoolean(this.value < o.value); } greater(o) { - return new BBoolean(this.compareTo(o) > 0); + return new BBoolean(this.value > o.value); } equal(o) { - return new BBoolean(this.compareTo(o) === 0); + return new BBoolean(this.value == o.value); } unequal(o) { - return new BBoolean(this.compareTo(o) != 0); + return new BBoolean(this.value != o.value); } intValue() { return this.value; @@ -49,7 +49,7 @@ export class BInteger { return new BInteger(this.value * o.value); } power(o) { - return new BInteger(this.value ^ o.value); + return new BInteger(Math.pow(this.value, o.value)); } divide(o) { return new BInteger(~~(this.value / o.value)); diff --git a/visualizations/LandingGear/HydraulicCircuit/btypes/BObject.js b/visualizations/LandingGear/HydraulicCircuit/btypes/BObject.js old mode 100755 new mode 100644 diff --git a/visualizations/LandingGear/HydraulicCircuit/btypes/BRelation.js b/visualizations/LandingGear/HydraulicCircuit/btypes/BRelation.js old mode 100755 new mode 100644 index 7532d0eb3d7ee48eb8c98e4c70e83e5a4c84416f..be5ebd625156f3884f75244e7b2a187bd9707011 --- a/visualizations/LandingGear/HydraulicCircuit/btypes/BRelation.js +++ b/visualizations/LandingGear/HydraulicCircuit/btypes/BRelation.js @@ -1,10 +1,10 @@ -import { BTuple } from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BTuple.js"; -import { BSet } from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BSet.js"; -import { BInteger } from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BInteger.js"; -import { BBoolean } from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BBoolean.js"; -import { BString } from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BString.js"; -import { BStruct } from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BStruct.js"; -import * as immutable from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/immutable/dist/immutable.es.js"; +import { BTuple } from "./BTuple.js"; +import { BSet } from "./BSet.js"; +import { BInteger } from "./BInteger.js"; +import { BBoolean } from "./BBoolean.js"; +import { BString } from "./BString.js"; +import { BStruct } from "./BStruct.js"; +import * as immutable from "../immutable/dist/immutable.es.js"; export class BRelation { constructor(...args) { if (args.length === 0) { @@ -59,28 +59,39 @@ export class BRelation { intersectionDomain.forEach((domainElement) => { let thisRangeSet = this.map.get(domainElement); let otherRangeSet = otherMap.get(domainElement); - resultMap = resultMap.set(domainElement, thisRangeSet.intersect(otherRangeSet)); + let newRangeSet = thisRangeSet.intersect(otherRangeSet); + if (newRangeSet.size === 0) { + resultMap = resultMap.delete(domainElement); + } + else { + resultMap = resultMap.set(domainElement, newRangeSet); + } }); differenceDomain.forEach((domainElement) => { - resultMap = resultMap.set(domainElement, immutable.Set()); + resultMap = resultMap.delete(domainElement); }); return new BRelation(resultMap); } difference(relation) { let otherMap = relation.map; - let otherDomain = otherMap.keys(); + let otherDomain = immutable.Set(otherMap.keys()); let thisDomain = immutable.Set(this.map.keys()); - let differenceDomain = thisDomain.subtract(otherDomain); - let restDomain = thisDomain.subtract(differenceDomain); + let intersectionDomain = thisDomain.intersect(otherDomain); let resultMap = this.map; - differenceDomain.forEach((domainElement) => { + for (let domainElement of intersectionDomain) { let thisRangeSet = this.map.get(domainElement); let otherRangeSet = otherMap.get(domainElement); - resultMap = resultMap.set(domainElement, thisRangeSet.subtract(otherRangeSet)); - }); - restDomain.forEach((domainElement) => { - resultMap = resultMap.set(domainElement, immutable.Set()); - }); + if (otherRangeSet == null) { + continue; + } + let newRangeSet = thisRangeSet.subtract(otherRangeSet); + if (newRangeSet.size === 0) { + resultMap = resultMap.delete(domainElement); + } + else { + resultMap = resultMap.set(domainElement, newRangeSet); + } + } return new BRelation(resultMap); } union(relation) { @@ -106,14 +117,17 @@ export class BRelation { } return size; } + _size() { + return new BInteger(this.size()); + } card() { return new BInteger(this.size()); } - equal(o) { - return new BBoolean(this.equals(o)); + equal(other) { + return this.subset(other).and(other.subset(this)); } - unequal(o) { - return new BBoolean(!this.equals(o)); + unequal(other) { + return this.equal(other).not(); } elementOf(object) { let prj1 = object.projection1(); @@ -135,14 +149,10 @@ export class BRelation { } relationImage(domain) { let resultSet = immutable.Set(); - for (let this_domain_elem of this.map.keys()) { - for (let other_domain_elem of domain.set) { - if (other_domain_elem.equals(this_domain_elem)) { - let thisRangeSet = this.map.get(this_domain_elem); - if (thisRangeSet != null) { - resultSet = BSet.immutableSetUnion(resultSet, thisRangeSet); - } - } + for (let domainElement of domain) { + let thisRangeSet = this.map.get(domainElement); + if (thisRangeSet != null) { + resultSet = BSet.immutableSetUnion(resultSet, thisRangeSet); } } return new BSet(resultSet); @@ -194,30 +204,82 @@ export class BRelation { let resultSet = immutable.Set(this.map.keys()); for (let domainElement of this.map.keys()) { let range = this.map.get(domainElement); - if (range.size === 0) { + if (range == null || range.size === 0) { resultSet = resultSet.remove(domainElement); } } return new BSet(resultSet); } + domainForRelations() { + let result = new BRelation(); + for (let elem of this.domain()) { + result = result.union(new BRelation(elem)); + } + return result; + } + isInDomain(arg) { + let thisMap = this.map; + let image = thisMap.get(arg); + if (image == null || image.size === 0) { + return new BBoolean(false); + } + return new BBoolean(true); + } + isNotInDomain(arg) { + return this.isInDomain(arg).not(); + } range() { let set = immutable.Set.union(this.map.values()); return new BSet(set); } + rangeForRelations() { + let result = new BRelation(); + for (let elem of this.range()) { + result = result.union(new BRelation(elem)); + } + return result; + } + isInRange(element) { + for (let domainElement of this.map.keys()) { + let range = this.map.get(domainElement); + if (range != null && range.has(element)) { + return new BBoolean(true); + } + } + return new BBoolean(false); + } + isNotInRange(element) { + return this.isInRange(element).not(); + } + isInRelationalImage(element, set) { + for (let key of set) { + let image = this.map.get(key); + if (image != null && image.has(element)) { + return new BBoolean(true); + } + } + return new BBoolean(false); + } + isNotInRelationalImage(element, set) { + return this.isInRelationalImage(element, set).not(); + } inverse() { let thisMap = this.map; let keys = immutable.Set(thisMap.keys()); let resultMap = immutable.Map(); for (let domainElement of keys) { - let range = this.map.get(domainElement); - range.forEach((rangeElement) => { + let range = thisMap.get(domainElement); + if (range == null) { + break; + } + for (let rangeElement of range) { let currentRange = resultMap.get(rangeElement); if (currentRange == null) { currentRange = immutable.Set(); } currentRange = currentRange.union(immutable.Set([domainElement])); resultMap = resultMap.set(rangeElement, currentRange); - }); + } } return new BRelation(resultMap); } @@ -251,7 +313,13 @@ export class BRelation { let resultMap = this.map; for (let domainElement of thisDomain) { let thisRangeSet = this.map.get(domainElement); - resultMap = resultMap.set(domainElement, BSet.immutableSetIntersection(thisRangeSet, otherSet)); + let newRangeSet = BSet.immutableSetIntersection(thisRangeSet, otherSet); + if (newRangeSet.size === 0) { + resultMap = resultMap.delete(domainElement); + } + else { + resultMap = resultMap.set(domainElement, newRangeSet); + } } return new BRelation(resultMap); } @@ -261,23 +329,50 @@ export class BRelation { let resultMap = this.map; for (let domainElement of thisDomain) { let thisRangeSet = this.map.get(domainElement); - resultMap = resultMap.set(domainElement, BSet.immutableSetDifference(thisRangeSet, otherSet)); + let newRangeSet = BSet.immutableSetDifference(thisRangeSet, otherSet); + if (newRangeSet.size === 0) { + resultMap = resultMap.delete(domainElement); + } + else { + resultMap = resultMap.set(domainElement, newRangeSet); + } } return new BRelation(resultMap); } + subset(arg) { + let thisDomain = immutable.Set(this.map.keys()); + for (let domainElement of thisDomain) { + let thisRangeSet = this.map.get(domainElement); + let otherRangeSet = arg.map.get(domainElement); + if (thisRangeSet != null && !(thisRangeSet.size === 0)) { + if (otherRangeSet == null) { + return new BBoolean(false); + } + for (let rangeElement of thisRangeSet) { + if (!otherRangeSet.contains(rangeElement)) { + return new BBoolean(false); + } + } + } + } + return new BBoolean(true); + } + notSubset(arg) { + return this.subset(arg).not(); + } + strictSubset(other) { + return new BBoolean(other.size() != this.size() && this.subset(other).booleanValue()); + } + strictNotSubset(other) { + return this.strictSubset(other).not(); + } override(arg) { let otherMap = arg.map; let otherDomain = immutable.Set(otherMap.keys()); let resultMap = this.map; - outer_loop: for (let domainElement of otherDomain) { - for (let thisDomainElement of resultMap.keys()) { - if (thisDomainElement.equals(domainElement)) { - let range = otherMap.get(domainElement); - resultMap = resultMap.set(thisDomainElement, range); - continue outer_loop; - } - } - resultMap = resultMap.set(domainElement, otherMap.get(domainElement)); + for (let domainElement of otherDomain) { + let range = otherMap.get(domainElement); + resultMap = resultMap.set(domainElement, range); } return new BRelation(resultMap); } @@ -416,28 +511,51 @@ export class BRelation { for (let domainElement of this.map.keys()) { let range = this.map.get(domainElement); let set = immutable.Set(); - range.forEach((rangeElement) => { + if (range == null) { + break; + } + for (let rangeElement of range) { let union_element = otherMap.get(rangeElement); if (union_element == null) { - return; + continue; } - set = set.union(union_element); - }); + set = set.union(otherMap.get(rangeElement)); + } + if (set.size === 0) { + continue; + } resultMap = resultMap.set(domainElement, set); } return new BRelation(resultMap); } + isInComposition(tuple, arg) { + let projection1 = tuple.projection1(); + let projection2 = tuple.projection2(); + let range = this.map.get(projection1); + if (range != null) { + for (let value of range) { + let range2 = arg.map.get(value); + if (range2 != null && range2.has(projection2)) { + return new BBoolean(true); + } + } + } + return new BBoolean(false); + } + isNotInComposition(tuple, arg) { + return this.isInComposition(tuple, arg).not(); + } iterate(n) { let thisRelation = this; - let result = BRelation.identity(this.domain().union(this.range())); - for (let i = new BInteger(1); i.lessEqual(n).booleanValue(); i = i.succ()) { + let result = this; + for (let i = new BInteger(2); i.lessEqual(n).booleanValue(); i = i.succ()) { result = result.composition(thisRelation); } return result; } closure() { let thisRelation = this; - let result = BRelation.identity(this.domain().union(this.range())); + let result = this.iterate(new BInteger(0)); let nextResult = result.composition(thisRelation); let lastResult = result; do { @@ -447,6 +565,25 @@ export class BRelation { } while (!result.equal(lastResult).booleanValue()); return result; } + isInClosure(tuple) { + let projection1 = tuple.projection1(); + let projection2 = tuple.projection2(); + let imageOfProjection1 = this.map.get(projection1); + if (imageOfProjection1 != null && imageOfProjection1.size > 0) { + return new BBoolean(true); + } + let keys = Array.from(this.map.keys()); + for (let key of keys) { + let image = this.map.get(key); + if (image != null && image.has(projection2)) { + return new BBoolean(true); + } + } + return new BBoolean(false); + } + isNotInClosure(tuple) { + return this.isInClosure(tuple).not(); + } closure1() { let thisRelation = this; let result = this; @@ -459,29 +596,116 @@ export class BRelation { } while (!result.equal(lastResult).booleanValue()); return result; } + isInClosure1(tuple) { + let inThisRelation = this.elementOf(tuple); + if (inThisRelation.booleanValue()) { + return inThisRelation; + } + let thisRelation = this; + let result = this; + let nextResult = result.composition(thisRelation); + let lastResult = null; + do { + inThisRelation = nextResult.elementOf(tuple); + if (inThisRelation.booleanValue()) { + return inThisRelation; + } + lastResult = result; + result = result.union(nextResult); + nextResult = result.composition(thisRelation); + } while (!result.equal(lastResult).booleanValue()); + return new BBoolean(false); + } + isNotInClosure1(tuple) { + return this.isInClosure1(tuple).not(); + } static projection1(arg1, arg2) { - let argSet1 = arg1.getSet(); - let argSet2 = arg2.getSet(); - let resultMap = immutable.Map(); - argSet1.forEach((e1) => { - argSet2.forEach((e2) => { - let tuple = new BTuple(e1, e2); - resultMap = resultMap.set(tuple, immutable.Set([e1])); + if (arg1 instanceof BSet && arg2 instanceof BSet) { + let argSet1 = arg1.getSet(); + let argSet2 = arg2.getSet(); + let resultMap = immutable.Map(); + argSet1.forEach((e1) => { + argSet2.forEach((e2) => { + let tuple = new BTuple(e1, e2); + resultMap = resultMap.set(tuple, immutable.Set([e1])); + }); }); - }); - return new BRelation(resultMap); + return new BRelation(resultMap); + } + else if (arg1 instanceof BSet && arg2 instanceof BRelation) { + let resultMap = immutable.Map(); + for (let e1 of arg1) { + for (let e2 of arg2) { + let tuple = new BTuple(e1, e2); + resultMap = resultMap.set(tuple, immutable.Set([e1])); + } + } + return new BRelation(resultMap); + } + else if (arg1 instanceof BRelation && arg2 instanceof BSet) { + let resultMap = immutable.Map(); + for (let e1 of arg1) { + for (let e2 of arg2) { + let tuple = new BTuple(e1, e2); + resultMap = resultMap.set(tuple, immutable.Set([e1])); + } + } + return new BRelation(resultMap); + } + else if (arg1 instanceof BRelation && arg2 instanceof BRelation) { + let resultMap = immutable.Map(); + for (let e1 of arg1) { + for (let e2 of arg2) { + let tuple = new BTuple(e1, e2); + resultMap = resultMap.set(tuple, immutable.Set([e1])); + } + } + return new BRelation(resultMap); + } } static projection2(arg1, arg2) { - let argSet1 = arg1.getSet(); - let argSet2 = arg2.getSet(); - let resultMap = immutable.Map(); - argSet1.forEach((e1) => { - argSet2.forEach((e2) => { - let tuple = new BTuple(e1, e2); - resultMap = resultMap.set(tuple, immutable.Set([e2])); - }); - }); - return new BRelation(resultMap); + if (arg1 instanceof BSet && arg2 instanceof BSet) { + let argSet1 = arg1.getSet(); + let argSet2 = arg2.getSet(); + let resultMap = immutable.Map(); + for (let e1 of arg1) { + for (let e2 of arg2) { + let tuple = new BTuple(e1, e2); + resultMap = resultMap.set(tuple, immutable.Set([e2])); + } + } + return new BRelation(resultMap); + } + else if (arg1 instanceof BSet && arg2 instanceof BRelation) { + let resultMap = immutable.Map(); + for (let e1 of arg1) { + for (let e2 of arg2) { + let tuple = new BTuple(e1, e2); + resultMap = resultMap.set(tuple, immutable.Set([e2])); + } + } + return new BRelation(resultMap); + } + else if (arg1 instanceof BRelation && arg2 instanceof BSet) { + let resultMap = immutable.Map(); + for (let e1 of arg1) { + for (let e2 of arg2) { + let tuple = new BTuple(e1, e2); + resultMap = resultMap.set(tuple, immutable.Set([e2])); + } + } + return new BRelation(resultMap); + } + else if (arg1 instanceof BRelation && arg2 instanceof BRelation) { + let resultMap = immutable.Map(); + for (let e1 of arg1) { + for (let e2 of arg2) { + let tuple = new BTuple(e1, e2); + resultMap = resultMap.set(tuple, immutable.Set([e2])); + } + } + return new BRelation(resultMap); + } } fnc() { let thisMap = this.map; @@ -489,7 +713,7 @@ export class BRelation { let resultMap = immutable.Map(); domain.forEach((domainElement) => { let range = thisMap.get(domainElement); - let rangeSet = new BSet([range]); + let rangeSet = new BSet(range); resultMap = resultMap.set(domainElement, immutable.Set([rangeSet])); }); return new BRelation(resultMap); @@ -505,18 +729,66 @@ export class BRelation { return new BRelation(resultMap); } static identity(arg) { - let resultMap = immutable.Map(); - arg.getSet().forEach((e) => { - resultMap = resultMap.set(e, immutable.Set([e])); - }); - return new BRelation(resultMap); + if (arg instanceof BSet) { + let resultMap = immutable.Map(); + arg.getSet().forEach((e) => { + resultMap = resultMap.set(e, immutable.Set([e])); + }); + return new BRelation(resultMap); + } + else if (arg instanceof BRelation) { + let resultMap = immutable.Map(); + for (let e of arg) { + resultMap = resultMap.set(e, immutable.Set([e])); + } + return new BRelation(resultMap); + } } static cartesianProduct(arg1, arg2) { - let resultMap = immutable.Map(); - arg1.getSet().forEach((e1) => { - resultMap = resultMap.set(e1, arg2.getSet()); - }); - return new BRelation(resultMap); + if (arg1 instanceof BSet && arg2 instanceof BSet) { + let resultMap = immutable.Map(); + for (let e1 of arg1) { + if (arg2.size().intValue() > 0) { + resultMap = resultMap.set(e1, arg2.getSet()); + } + } + return new BRelation(resultMap); + } + else if (arg1 instanceof BRelation && arg2 instanceof BSet) { + let resultMap = immutable.Map(); + for (let e1 of arg1) { + if (arg2.size().intValue() > 0) { + resultMap = resultMap.set(e1, arg2.getSet()); + } + } + return new BRelation(resultMap); + } + else if (arg1 instanceof BSet && arg2 instanceof BRelation) { + let resultMap = immutable.Map(); + for (let e1 of arg1) { + let rangeSet = immutable.Set(); + for (let e2 of arg2) { + rangeSet = rangeSet.add(e2); + } + if (!rangeSet.isEmpty()) { + resultMap = resultMap.set(e1, rangeSet); + } + } + return new BRelation(resultMap); + } + else if (arg1 instanceof BRelation && arg2 instanceof BRelation) { + let resultMap = immutable.Map(); + for (let e1 of arg1) { + let rangeSet = immutable.Set(); + for (let e2 of arg2) { + rangeSet = rangeSet.add(e2); + } + if (!rangeSet.isEmpty()) { + resultMap = resultMap.set(e1, rangeSet); + } + } + return new BRelation(resultMap); + } } nondeterminism() { let domain = immutable.Set(this.map.keys()); @@ -547,7 +819,16 @@ export class BRelation { return null; } isTotal(domain) { - return new BBoolean(this.domain().equal(domain)); + if (domain instanceof (BSet)) { + return new BBoolean(this.domain().equal(domain)); + } + else { + let domainAsSet = new BSet(); + for (let tuple of domain) { + domainAsSet = domainAsSet.union(new BSet(tuple)); + } + return this.domain().equal(domainAsSet); + } } isTotalInteger() { return new BBoolean(false); @@ -565,153 +846,209 @@ export class BRelation { return new BBoolean(false); } isPartial(domain) { - return this.domain().strictSubset(domain); + if (domain instanceof BSet) { + return this.domain().subset(domain); + } + else { + for (let element of this.domain()) { + let elementAsTuple = element; + let range = domain.map.get(elementAsTuple.projection1()); + if (range == null) { + return new BBoolean(false); + } + if (!range.contains(elementAsTuple.projection2())) { + return new BBoolean(false); + } + } + return new BBoolean(true); + } } isPartialInteger() { - this.domain().getSet().forEach((e) => { + for (let e of this.domain().getSet()) { if (e instanceof BInteger) { return new BBoolean(true); } else { return new BBoolean(false); } - }); + } return new BBoolean(true); } isPartialNatural() { - this.domain().getSet().forEach((e) => { + for (let e of this.domain().getSet()) { if (e instanceof BInteger && !e.isNatural().booleanValue()) { return new BBoolean(false); } - }); + } return new BBoolean(true); } isPartialNatural1() { - this.domain().getSet().forEach((e) => { + for (let e of this.domain().getSet()) { if (e instanceof BInteger && !e.isNatural1().booleanValue()) { return new BBoolean(false); } - }); + } return new BBoolean(true); } isPartialString() { - this.domain().getSet().forEach((e) => { + for (let e of this.domain().getSet()) { if (e instanceof BString && !e.isString().booleanValue()) { return new BBoolean(false); } - }); + } return new BBoolean(true); } isPartialStruct() { - this.domain().getSet().forEach((e) => { + for (let e of this.domain().getSet()) { if (e instanceof BStruct && !e.isRecord().booleanValue()) { return new BBoolean(false); } - }); + } return new BBoolean(true); } checkDomain(domain) { - return this.domain().subset(domain); + if (domain instanceof BSet) { + return this.domain().subset(domain); + } + else { + for (let element of this.domain()) { + let elementAsTuple = element; + let range = domain.map.get(elementAsTuple.projection1()); + if (range == null) { + return new BBoolean(false); + } + if (!range.contains(elementAsTuple.projection2())) { + return new BBoolean(false); + } + } + return new BBoolean(true); + } } checkDomainInteger() { - this.domain().getSet().forEach((e) => { + for (let e of this.domain().getSet()) { if (e instanceof BInteger) { return new BBoolean(true); } else { return new BBoolean(false); } - }); + } return new BBoolean(true); } checkDomainNatural() { - this.domain().getSet().forEach((e) => { + for (let e of this.domain().getSet()) { if (e instanceof BInteger && !e.isNatural().booleanValue()) { return new BBoolean(false); } - }); + } return new BBoolean(true); } checkDomainNatural1() { - this.domain().getSet().forEach((e) => { + for (let e of this.domain().getSet()) { if (e instanceof BInteger && !e.isNatural1().booleanValue()) { return new BBoolean(false); } - }); + } return new BBoolean(true); } checkDomainString() { - this.domain().getSet().forEach((e) => { + for (let e of this.domain().getSet()) { if (e instanceof BString && !e.isString().booleanValue()) { return new BBoolean(false); } - }); + } return new BBoolean(true); } checkDomainStruct() { - this.domain().getSet().forEach((e) => { + for (let e of this.domain().getSet()) { if (e instanceof BStruct && !e.isRecord().booleanValue()) { return new BBoolean(false); } - }); + } return new BBoolean(true); } checkRange(range) { - return this.range().subset(range); + if (range instanceof BSet) { + return this.range().subset(range); + } + else { + for (let element of this.range()) { + let elementAsTuple = element; + let rangeRange = range.map.get(elementAsTuple.projection1()); + if (rangeRange == null) { + return new BBoolean(false); + } + if (!rangeRange.contains(elementAsTuple.projection2())) { + return new BBoolean(false); + } + } + return new BBoolean(true); + } } checkRangeInteger() { - this.range().getSet().forEach((e) => { + for (let e of this.range().getSet()) { if (e instanceof BInteger) { return new BBoolean(true); } else { return new BBoolean(false); } - }); + } + return new BBoolean(true); + } + checkRangeBoolean() { + for (let e of this.range().getSet()) { + if (e instanceof BBoolean) { + return new BBoolean(true); + } + else { + return new BBoolean(false); + } + } return new BBoolean(true); } checkRangeNatural() { - this.range().getSet().forEach((e) => { + for (let e of this.range().getSet()) { if (e instanceof BInteger && !e.isNatural().booleanValue()) { return new BBoolean(false); } - }); + } return new BBoolean(true); } checkRangeNatural1() { - this.range().getSet().forEach((e) => { + for (let e of this.range().getSet()) { if (e instanceof BInteger && !e.isNatural1().booleanValue()) { return new BBoolean(false); } - }); + } return new BBoolean(true); } checkRangeString() { - this.range().getSet().forEach((e) => { + for (let e of this.range().getSet()) { if (e instanceof BString && !e.isString().booleanValue()) { return new BBoolean(false); } - }); + } return new BBoolean(true); } checkRangeStruct() { - this.range().getSet().forEach((e) => { + for (let e of this.range().getSet()) { if (e instanceof BStruct && !e.isRecord().booleanValue()) { return new BBoolean(false); } - }); + } return new BBoolean(true); } isRelation() { return new BBoolean(true); } isFunction() { - this.domain().getSet().forEach((element) => { + for (let element of this.domain().getSet()) { let range = this.map.get(element); if (range.size > 1) { return new BBoolean(false); } - }); + } return new BBoolean(true); } isSurjection(range) { @@ -734,15 +1071,15 @@ export class BRelation { } isInjection() { let visited = immutable.Set(); - this.domain().getSet().forEach((element) => { + for (let element of this.domain().getSet()) { let range = this.map.get(element); - range.forEach((rangeElement) => { + for (let rangeElement of range) { if (visited.contains(rangeElement)) { return new BBoolean(false); } visited = visited.union(immutable.Set([rangeElement])); - }); - }); + } + } return new BBoolean(true); } isBijection(range) { @@ -788,4 +1125,42 @@ export class BRelation { hashCode() { return this.map.hashCode(); } + [Symbol.iterator]() { + let thisMap = this.map; + let keyIterator = thisMap.keys(); + let currentLhs = keyIterator.next().value; + let valueIterator = currentLhs == null ? null : thisMap.get(currentLhs).values(); + return { + next: function () { + // If there is no next key, then we have already iterated through the relation + if (currentLhs == null) { + return { + done: true, + value: null + }; + } + let nextValueIterator = valueIterator.next(); + if (valueIterator == null || nextValueIterator.value == null) { + currentLhs = keyIterator.next().value; + valueIterator = currentLhs == null ? null : thisMap.get(currentLhs).values(); + if (currentLhs == null) { + return { + done: true, + value: null + }; + } + return { + done: false, + value: new BTuple(currentLhs, valueIterator.next().value) + }; + } + else { + return { + done: false, + value: new BTuple(currentLhs, nextValueIterator.value) + }; + } + }.bind(this) + }; + } } diff --git a/visualizations/LandingGear/HydraulicCircuit/btypes/BSet.js b/visualizations/LandingGear/HydraulicCircuit/btypes/BSet.js old mode 100755 new mode 100644 index c947d0c7a008a4a4d0e934c09fd9776d1b26dc45..717b83d1e2f01d999af587f6cc68738756ccec75 --- a/visualizations/LandingGear/HydraulicCircuit/btypes/BSet.js +++ b/visualizations/LandingGear/HydraulicCircuit/btypes/BSet.js @@ -1,9 +1,9 @@ -import { BBoolean } from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BBoolean.js"; -import { BInteger } from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BInteger.js"; -import { BRelation } from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BRelation.js"; -import { BString } from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BString.js"; -import { BStruct } from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BStruct.js"; -import * as immutable from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/immutable/dist/immutable.es.js"; +import { BBoolean } from "./BBoolean.js"; +import { BInteger } from "./BInteger.js"; +import { BRelation } from "./BRelation.js"; +import { BString } from "./BString.js"; +import { BStruct } from "./BStruct.js"; +import * as immutable from "../immutable/dist/immutable.es.js"; export class BSet { constructor(...args) { if (args.length == 1 && args[0] instanceof immutable.Set) { @@ -22,7 +22,7 @@ export class BSet { } toString() { let sb = "{"; - this.set.forEach(element => { + this.set.forEach((element) => { if (sb.length > 1) { sb += ", "; } @@ -31,32 +31,26 @@ export class BSet { sb += "}"; return sb; } - union(other = null) { - if (other == null) { - if (this.set.size === 0) { - return new BSet(); - } - else if (this.set.values().next().value instanceof BSet) { - let result = immutable.Set(); - for (let current_set of this.set) { - result = BSet.immutableSetUnion(result, current_set.set); - } - return new BSet(result); - } - else if (this.set.values().next().value instanceof BRelation) { - let result = immutable.Map(); - for (let current_set of this.set) { - result = BSet.immutableMapUnion(result, current_set.map); - } - return new BRelation(result); - } - else { - throw new Error("Generalized Union is only possible on immutable.Sets of immutable.Sets or Relations"); - } - } + union(other) { let result = BSet.immutableSetUnion(this.set, other.set); return new BSet(result); } + unionForSets() { + if (this.set.isEmpty()) { + return new BSet(); + } + else { + return this.set.reduce((a, e) => a.union(e), new BSet()); + } + } + unionForRelations() { + if (this.set.isEmpty()) { + return new BRelation(); + } + else { + return this.set.reduce((a, e) => a.union(e), new BRelation()); + } + } static immutableSetUnion(s1, s2) { return s1.union(s2); } @@ -96,31 +90,25 @@ export class BSet { } return result; } - intersect(other = null) { - if (other == null) { - if (this.set.size === 0) { - return new BSet(); - } - else if (this.set.values().next().value instanceof BSet) { - let result = this.set.values().next().value.set; - for (let current_set of this.set) { - result = BSet.immutableSetDifference(result, BSet.immutableSetDifference(result, current_set.set)); - } - return new BSet(result); - } - else if (this.set.values().next().value instanceof BRelation) { - let result = this.set.values().next().value.map; - for (let current_set of this.set) { - result = BSet.immutableMapIntersection(result, current_set.map); - } - return new BRelation(result); - } - else { - throw new Error("Generalized Intersection is only possible on immutable.Sets of immutable.Sets or Relations"); - } + intersect(other) { + let result = BSet.immutableSetIntersection(this.set, other.set); + return new BSet(result); + } + intersectForSets() { + if (this.set.isEmpty()) { + return new BSet(); + } + else { + return this.set.reduce((a, e) => a.intersect(e)); + } + } + intersectForRelations() { + if (this.set.isEmpty()) { + return new BRelation(); + } + else { + return this.set.reduce((a, e) => a.intersect(e)); } - let new_set = BSet.immutableSetDifference(this.set, BSet.immutableSetDifference(this.set, other.set)); - return new BSet(new_set); } difference(other) { let set = BSet.immutableSetDifference(this.set, other.set); @@ -139,35 +127,24 @@ export class BSet { return new BBoolean(!this.set.has(obj)); } subset(other) { - this_set_loop: for (let elem of this.set) { - for (let other_elem of other.set) { - if (other_elem.equals(elem)) { - continue this_set_loop; - } + for (let element of this.set) { + if (!other.getSet().has(element)) { + return new BBoolean(false); } - return new BBoolean(false); } return new BBoolean(true); } notSubset(other) { - this_set_loop: for (let elem of this.set) { - for (let other_elem of other.set) { - if (other_elem.equals(elem)) { - continue this_set_loop; - } - } - return new BBoolean(true); - } - return new BBoolean(false); + return this.subset(other).not(); } strictSubset(other) { - return this.size().less(other.size()).and(this.subset(other)); + return new BBoolean(other.getSet().size != this.set.size && this.subset(other).booleanValue()); } strictNotSubset(other) { - return this.size().equal(other.size()).and(this.notSubset(other)); + return this.strictSubset(other).not(); } contains(other) { - return other.toString() in this.set; + return other in this.set; } containsAll(other) { for (let o of other.set) { @@ -181,12 +158,12 @@ export class BSet { return this.set.size === 0; } equals(other) { - return this.equal(other).booleanValue(); - } - equal(other) { if (!(other instanceof BSet)) { - return new BBoolean(false); + return false; } + return this.set.equals(other.set); + } + equal(other) { return this.subset(other).and(other.subset(this)); } unequal(other) { @@ -200,14 +177,18 @@ export class BSet { return values[Math.floor(Math.random() * values.length)]; } min() { - return this.set.reduce((a, v) => { if (a < v) { - return a; - } return v; }); + if (this.size().intValue() == 0) { + throw new Error("Minimum does not exist"); + } + let result = this.set.reduce((a, b) => a.lessEqual(b).booleanValue() ? a : b); + return result; } max() { - return this.set.reduce((a, v) => { if (a > v) { - return a; - } return v; }); + if (this.size().intValue() == 0) { + throw new Error("Maximum does not exist"); + } + let result = this.set.reduce((a, b) => a.greaterEqual(b).booleanValue() ? a : b); + return result; } pow() { let result = new BSet(); @@ -237,81 +218,113 @@ export class BSet { fin1() { return this.pow1(); } + subsetOfBoolean() { + for (let e of this.getSet()) { + if (e instanceof BBoolean) { + return new BBoolean(true); + } + else { + return new BBoolean(false); + } + } + return new BBoolean(true); + } + strictSubsetOfBoolean() { + return this.subsetOfBoolean(); + } + notSubsetOfBoolean() { + return this.subsetOfBoolean().not(); + } + equalBoolean() { + return new BBoolean(this.subsetOfBoolean().booleanValue() && this.size().intValue() == 2); + } + unequalBoolean() { + return new BBoolean(this.subsetOfBoolean().booleanValue() && this.size().intValue() < 2); + } subsetOfInteger() { for (let element of this.set) { - if (element instanceof BInteger) { - return false; + if (!(element instanceof BInteger)) { + return new BBoolean(false); } } - return true; + return new BBoolean(true); } strictSubsetOfInteger() { return this.subsetOfInteger(); } notSubsetOfInteger() { - return !this.subsetOfInteger(); + return this.subsetOfInteger().not(); } notStrictSubsetOfInteger() { - return !this.strictSubsetOfInteger(); + return this.strictSubsetOfInteger().not(); } subsetOfNatural() { for (let element of this.set) { if (!(element instanceof BInteger && element.isNatural().booleanValue())) { - return false; + return new BBoolean(false); } } - return true; + return new BBoolean(true); } strictSubsetOfNatural() { return this.subsetOfNatural(); } notSubsetOfNatural() { - return !this.subsetOfNatural(); + return this.subsetOfNatural().not(); } notStrictSubsetOfNatural() { - return !this.strictSubsetOfNatural(); + return this.strictSubsetOfNatural().not(); } subsetOfNatural1() { for (let element of this.set) { if (!(element instanceof BInteger && element.isNatural1().booleanValue())) { - return false; + return new BBoolean(false); } } - return true; + return new BBoolean(true); + } + strictSubsetOfNatural1() { + return this.subsetOfNatural1(); + } + notSubsetOfNatural1() { + return this.subsetOfNatural1().not(); + } + notStrictSubsetOfNatural1() { + return this.strictSubsetOfNatural1().not(); } subsetOfString() { for (let element of this.set) { if (!(element instanceof BString)) { - return false; + return new BBoolean(false); } } - return true; + return new BBoolean(true); } strictSubsetOfString() { return this.subsetOfString(); } notSubsetOfString() { - return !this.subsetOfString(); + return this.subsetOfString().not(); } notStrictSubsetOfString() { - return !this.strictSubsetOfString(); + return this.strictSubsetOfString().not(); } subsetOfStruct() { for (let element of this.set) { if (!(element instanceof BStruct)) { - return false; + return new BBoolean(false); } } - return true; + return new BBoolean(true); } strictSubsetOfStruct() { return this.subsetOfStruct(); } notSubsetOfStruct() { - return !this.subsetOfStruct(); + return this.subsetOfStruct().not(); } notStrictSubsetOfStruct() { - return !this.strictSubsetOfStruct(); + return this.strictSubsetOfStruct().not(); } equalInteger() { return new BBoolean(false); @@ -350,8 +363,11 @@ export class BSet { if (b.less(a).booleanValue()) { return new BSet(); } - const range = [...Array(b.minus(a).intValue() + 1).keys()].map(e => new BInteger(e).plus(a)); - return new BSet(immutable.Set(range)); + let persistentSet = immutable.Set(); + for (let i = a; i.lessEqual(b).booleanValue(); i = i.plus(new BInteger(1))) { + persistentSet = persistentSet.add(i); + } + return new BSet(persistentSet); } hashCode() { return this.set.hashCode(); diff --git a/visualizations/LandingGear/HydraulicCircuit/btypes/BString.js b/visualizations/LandingGear/HydraulicCircuit/btypes/BString.js old mode 100755 new mode 100644 index 53127caeca1a7387f2311974aabb745fc0d94bab..27ea018fd10eea10efd33176471965979feb40b3 --- a/visualizations/LandingGear/HydraulicCircuit/btypes/BString.js +++ b/visualizations/LandingGear/HydraulicCircuit/btypes/BString.js @@ -1,4 +1,4 @@ -import { BBoolean } from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BBoolean.js"; +import { BBoolean } from "./BBoolean.js"; export class BString { constructor(value) { this.value = value; @@ -12,6 +12,12 @@ export class BString { } return this.value === o.value; } + equal(o) { + return new BBoolean(this.equals(o)); + } + unequal(o) { + return new BBoolean(!this.equals(o)); + } length() { return this.value.length; } diff --git a/visualizations/LandingGear/HydraulicCircuit/btypes/BStruct.js b/visualizations/LandingGear/HydraulicCircuit/btypes/BStruct.js old mode 100755 new mode 100644 index ffc6874b72f80576983e3871f8f5280c9df18377..196b0fa0e643f72a865a96d09c27c76f5ed92fdd --- a/visualizations/LandingGear/HydraulicCircuit/btypes/BStruct.js +++ b/visualizations/LandingGear/HydraulicCircuit/btypes/BStruct.js @@ -1,4 +1,4 @@ -import { BBoolean } from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BBoolean.js"; +import { BBoolean } from "./BBoolean.js"; export class BStruct { isRecord() { return new BBoolean(true); diff --git a/visualizations/LandingGear/HydraulicCircuit/btypes/BTuple.js b/visualizations/LandingGear/HydraulicCircuit/btypes/BTuple.js old mode 100755 new mode 100644 index 2de0879f4432d4b02e6221469d1cde1551089749..49f6bba5979626f54da241bc2aee21b680b45674 --- a/visualizations/LandingGear/HydraulicCircuit/btypes/BTuple.js +++ b/visualizations/LandingGear/HydraulicCircuit/btypes/BTuple.js @@ -1,4 +1,4 @@ -import { BBoolean } from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BBoolean.js"; +import { BBoolean } from "./BBoolean.js"; export class BTuple { constructor(first, second) { if (first == null || second == null) { diff --git a/visualizations/LandingGear/HydraulicCircuit/btypes/BUtils.js b/visualizations/LandingGear/HydraulicCircuit/btypes/BUtils.js old mode 100755 new mode 100644 index ee8c23607313ad0c9e6ef3953327eb6a3664b0e5..5bccb4e1448bf429d1e93c4c5443f53d44befd4c --- a/visualizations/LandingGear/HydraulicCircuit/btypes/BUtils.js +++ b/visualizations/LandingGear/HydraulicCircuit/btypes/BUtils.js @@ -1,5 +1,5 @@ -import { BSet } from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BSet.js"; -import { BBoolean } from "https://favu100.github.io/b2program/visualizations/LandingGear/HydraulicCircuit/btypes/BBoolean.js"; +import { BSet } from "./BSet.js"; +import { BBoolean } from "./BBoolean.js"; export class BUtils { } BUtils.BOOL = new BSet(new BBoolean(true), new BBoolean(false)); @@ -8,4 +8,22 @@ export class SelectError extends Error { super(msg); Object.setPrototypeOf(this, SelectError.prototype); } -} \ No newline at end of file +} +export class PreconditionOrAssertionViolation extends Error { + constructor(msg) { + super(msg); + Object.setPrototypeOf(this, PreconditionOrAssertionViolation.prototype); + } +} +export class VariantViolation extends Error { + constructor(msg) { + super(msg); + Object.setPrototypeOf(this, SelectError.prototype); + } +} +export class LoopInvariantViolation extends Error { + constructor(msg) { + super(msg); + Object.setPrototypeOf(this, SelectError.prototype); + } +}