#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class X:
class Status(Enum):
s1 = "s1"
Final = "Final"
s2 = "s2"
s3 = "s3"
def __str__(self):
return self.value
class StatusS1S11(Enum):
Null = "Null"
s11 = "s11"
fState1 = "fState1"
def __str__(self):
return self.value
class StatusS1S11S11(Enum):
Null = "Null"
s111 = "s111"
def __str__(self):
return self.value
class StatusS1S11S11S111(Enum):
Null = "Null"
s111 = "s111"
def __str__(self):
return self.value
class StatusS1S12(Enum):
Null = "Null"
s12 = "s12"
def __str__(self):
return self.value
class StatusS1S12S12(Enum):
Null = "Null"
s122 = "s122"
fState2 = "fState2"
def __str__(self):
return self.value
def __init__(self):
self._status = None
self._statusVisit = 0
self._statusS1S11 = None
self._statusS1S11Visit = 0
self._statusS1S11S11 = None
self._statusS1S11S11Visit = 0
self._statusS1S11S11S111 = None
self._statusS1S12 = None
self._statusS1S12Visit = 0
self._statusS1S12S12 = None
self._statusS1S12S12Visit = 0
self._deleted = False
self.setStatusS1S11(__class__.StatusS1S11.Null)
if self._deleted:
return
self.setStatusS1S11S11(__class__.StatusS1S11S11.Null)
if self._deleted:
return
self.setStatusS1S11S11S111(__class__.StatusS1S11S11S111.Null)
if self._deleted:
return
self.setStatusS1S12(__class__.StatusS1S12.Null)
if self._deleted:
return
self.setStatusS1S12S12(__class__.StatusS1S12S12.Null)
if self._deleted:
return
self.setStatus(__class__.Status.s1)
if self._deleted:
return
def getStatusFullName(self):
answer = str(self._status)
if self._statusS1S11 is not __class__.StatusS1S11.Null:
answer += "." + str(self._statusS1S11)
if self._statusS1S11S11 is not __class__.StatusS1S11S11.Null:
answer += "." + str(self._statusS1S11S11)
if self._statusS1S11S11S111 is not __class__.StatusS1S11S11S111.Null:
answer += "." + str(self._statusS1S11S11S111)
if self._statusS1S12 is not __class__.StatusS1S12.Null:
answer += "." + str(self._statusS1S12)
if self._statusS1S12S12 is not __class__.StatusS1S12S12.Null:
answer += "." + str(self._statusS1S12S12)
return answer
def getStatus(self):
return self._status
def getStatusS1S11(self):
return self._statusS1S11
def getStatusS1S11S11(self):
return self._statusS1S11S11
def getStatusS1S11S11S111(self):
return self._statusS1S11S11S111
def getStatusS1S12(self):
return self._statusS1S12
def getStatusS1S12S12(self):
return self._statusS1S12S12
def e2(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.s1:
self.exitStatus()
if self._deleted:
return True
self.setStatus(__class__.Status.s2)
wasEventProcessed = True
return wasEventProcessed
def e4(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.s2:
self.setStatus(__class__.Status.Final)
wasEventProcessed = True
return wasEventProcessed
def e3(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.s2:
self.setStatus(__class__.Status.s3)
wasEventProcessed = True
return wasEventProcessed
def e(self):
if self._deleted:
return False
wasEventProcessed = False
aStatusS1S11S11S111 = self._statusS1S11S11S111
if aStatusS1S11S11S111 is __class__.StatusS1S11S11S111.s111:
self.exitStatus()
if self._deleted:
return True
self.setStatus(__class__.Status.Final)
wasEventProcessed = True
return wasEventProcessed
def d1(self):
if self._deleted:
return False
wasEventProcessed = False
aStatusS1S11S11S111 = self._statusS1S11S11S111
if aStatusS1S11S11S111 is __class__.StatusS1S11S11S111.s111:
self.exitStatusS1S11()
if self._deleted:
return True
self.setStatusS1S11(__class__.StatusS1S11.fState1)
wasEventProcessed = True
return wasEventProcessed
def d2(self):
if self._deleted:
return False
wasEventProcessed = False
aStatusS1S12S12 = self._statusS1S12S12
if aStatusS1S12S12 is __class__.StatusS1S12S12.s122:
self.exitStatusS1S12S12()
if self._deleted:
return True
self.setStatusS1S12S12(__class__.StatusS1S12S12.fState2)
wasEventProcessed = True
return wasEventProcessed
def exitStatus(self):
self._statusVisit += 1
if self._status is __class__.Status.s1:
self.exitStatusS1S11()
if self._deleted:
return
self.exitStatusS1S12()
if self._deleted:
return
print("t4")
def setStatus(self, aStatus):
self._status = aStatus
self._statusVisit += 1
visit = self._statusVisit
if self._status is __class__.Status.s1:
if self._statusS1S11 is __class__.StatusS1S11.Null:
self.setStatusS1S11(__class__.StatusS1S11.s11)
if self._deleted or self._statusVisit != visit:
return
if self._statusS1S12 is __class__.StatusS1S12.Null:
self.setStatusS1S12(__class__.StatusS1S12.s12)
elif self._status is __class__.Status.Final:
self.delete()
elif self._status is __class__.Status.s3:
self.delete()
def exitStatusS1S11(self):
self._statusS1S11Visit += 1
if self._statusS1S11 is __class__.StatusS1S11.s11:
self.exitStatusS1S11S11()
if self._deleted:
return
print("t3")
if self._deleted:
return
self.setStatusS1S11(__class__.StatusS1S11.Null)
elif self._statusS1S11 is __class__.StatusS1S11.fState1:
self.setStatusS1S11(__class__.StatusS1S11.Null)
def setStatusS1S11(self, aStatusS1S11):
self._statusS1S11 = aStatusS1S11
self._statusS1S11Visit += 1
visit = self._statusS1S11Visit
if self._status is not __class__.Status.s1 and aStatusS1S11 is not __class__.StatusS1S11.Null:
self.setStatus(__class__.Status.s1)
if self._deleted or self._statusS1S11Visit != visit:
return
if self._statusS1S11 is __class__.StatusS1S11.s11:
if self._statusS1S11S11 is __class__.StatusS1S11S11.Null:
self.setStatusS1S11S11(__class__.StatusS1S11S11.s111)
elif self._statusS1S11 is __class__.StatusS1S11.fState1:
if self._statusS1S12S12 is __class__.StatusS1S12S12.fState2:
self.delete()
def exitStatusS1S11S11(self):
self._statusS1S11S11Visit += 1
if self._statusS1S11S11 is __class__.StatusS1S11S11.s111:
self.exitStatusS1S11S11S111()
if self._deleted:
return
print("t2")
if self._deleted:
return
self.setStatusS1S11S11(__class__.StatusS1S11S11.Null)
def setStatusS1S11S11(self, aStatusS1S11S11):
self._statusS1S11S11 = aStatusS1S11S11
self._statusS1S11S11Visit += 1
visit = self._statusS1S11S11Visit
if self._statusS1S11 is not __class__.StatusS1S11.s11 and aStatusS1S11S11 is not __class__.StatusS1S11S11.Null:
self.setStatusS1S11(__class__.StatusS1S11.s11)
if self._deleted or self._statusS1S11S11Visit != visit:
return
if self._statusS1S11S11 is __class__.StatusS1S11S11.s111:
if self._statusS1S11S11S111 is __class__.StatusS1S11S11S111.Null:
self.setStatusS1S11S11S111(__class__.StatusS1S11S11S111.s111)
def exitStatusS1S11S11S111(self):
if self._statusS1S11S11S111 is __class__.StatusS1S11S11S111.s111:
print("t1")
if self._deleted:
return
self.setStatusS1S11S11S111(__class__.StatusS1S11S11S111.Null)
def setStatusS1S11S11S111(self, aStatusS1S11S11S111):
self._statusS1S11S11S111 = aStatusS1S11S11S111
if self._statusS1S11S11 is not __class__.StatusS1S11S11.s111 and aStatusS1S11S11S111 is not __class__.StatusS1S11S11S111.Null:
self.setStatusS1S11S11(__class__.StatusS1S11S11.s111)
if self._deleted:
return
def exitStatusS1S12(self):
self._statusS1S12Visit += 1
if self._statusS1S12 is __class__.StatusS1S12.s12:
self.exitStatusS1S12S12()
if self._deleted:
return
self.setStatusS1S12(__class__.StatusS1S12.Null)
def setStatusS1S12(self, aStatusS1S12):
self._statusS1S12 = aStatusS1S12
self._statusS1S12Visit += 1
visit = self._statusS1S12Visit
if self._status is not __class__.Status.s1 and aStatusS1S12 is not __class__.StatusS1S12.Null:
self.setStatus(__class__.Status.s1)
if self._deleted or self._statusS1S12Visit != visit:
return
if self._statusS1S12 is __class__.StatusS1S12.s12:
if self._statusS1S12S12 is __class__.StatusS1S12S12.Null:
self.setStatusS1S12S12(__class__.StatusS1S12S12.s122)
def exitStatusS1S12S12(self):
self._statusS1S12S12Visit += 1
if self._statusS1S12S12 is __class__.StatusS1S12S12.s122:
self.setStatusS1S12S12(__class__.StatusS1S12S12.Null)
elif self._statusS1S12S12 is __class__.StatusS1S12S12.fState2:
self.setStatusS1S12S12(__class__.StatusS1S12S12.Null)
def setStatusS1S12S12(self, aStatusS1S12S12):
self._statusS1S12S12 = aStatusS1S12S12
self._statusS1S12S12Visit += 1
visit = self._statusS1S12S12Visit
if self._statusS1S12 is not __class__.StatusS1S12.s12 and aStatusS1S12S12 is not __class__.StatusS1S12S12.Null:
self.setStatusS1S12(__class__.StatusS1S12.s12)
if self._deleted or self._statusS1S12S12Visit != visit:
return
if self._statusS1S12S12 is __class__.StatusS1S12S12.fState2:
if self._statusS1S11 is __class__.StatusS1S11.fState1:
self.delete()
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class A_Guard:
class Status(Enum):
S1 = "S1"
S2 = "S2"
S3 = "S3"
def __str__(self):
return self.value
def __init__(self):
self._status = None
self._statusVisit = 0
self._deleted = False
self.setStatus(__class__.Status.S1)
if self._deleted:
return
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def e1(self, myB):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
visit = self._statusVisit
if aStatus is __class__.Status.S1:
guard = self.checkGuard1(myB)
if self._deleted:
return True
if self._statusVisit != visit:
return wasEventProcessed
if guard:
self.setStatus(__class__.Status.S2)
wasEventProcessed = True
return wasEventProcessed
def e2(self, myB, mySecondB):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
visit = self._statusVisit
if aStatus is __class__.Status.S2:
guard = self.checkGuard1(myB)
if self._deleted:
return True
if self._statusVisit != visit:
return wasEventProcessed
if guard:
self.setStatus(__class__.Status.S3)
wasEventProcessed = True
elif aStatus is __class__.Status.S3:
guard = self.checkGuard2(myB, mySecondB)
if self._deleted:
return True
if self._statusVisit != visit:
return wasEventProcessed
if guard:
self.setStatus(__class__.Status.S1)
wasEventProcessed = True
return wasEventProcessed
def setStatus(self, aStatus):
self._status = aStatus
self._statusVisit += 1
def delete(self):
self._deleted = True
def checkGuard1(self, myB):
# line 19 "../testTwoParameterGuardPython.ump"
return True
# end line
def checkGuard2(self, myB, mySecondB):
# line 22 "../testTwoParameterGuardPython.ump"
return True
# end line
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class X:
class Sm(Enum):
s0 = "s0"
s1 = "s1"
def __str__(self):
return self.value
class SmS0T1(Enum):
Null = "Null"
t1 = "t1"
def __str__(self):
return self.value
class SmS0T2(Enum):
Null = "Null"
t2 = "t2"
t3 = "t3"
def __str__(self):
return self.value
class SmS1T4(Enum):
Null = "Null"
t4 = "t4"
t5 = "t5"
def __str__(self):
return self.value
class SmS1T6(Enum):
Null = "Null"
t6 = "t6"
t7 = "t7"
def __str__(self):
return self.value
def __init__(self):
self._sm = None
self._smVisit = 0
self._smS0T1 = None
self._smS0T2 = None
self._smS0T2Visit = 0
self._smS1T4 = None
self._smS1T6 = None
self._smS1T6Visit = 0
self._deleted = False
self.setSmS0T1(__class__.SmS0T1.Null)
if self._deleted:
return
self.setSmS0T2(__class__.SmS0T2.Null)
if self._deleted:
return
self.setSmS1T4(__class__.SmS1T4.Null)
if self._deleted:
return
self.setSmS1T6(__class__.SmS1T6.Null)
if self._deleted:
return
self.setSm(__class__.Sm.s0)
if self._deleted:
return
def getSmFullName(self):
answer = str(self._sm)
if self._smS0T1 is not __class__.SmS0T1.Null:
answer += "." + str(self._smS0T1)
if self._smS0T2 is not __class__.SmS0T2.Null:
answer += "." + str(self._smS0T2)
if self._smS1T4 is not __class__.SmS1T4.Null:
answer += "." + str(self._smS1T4)
if self._smS1T6 is not __class__.SmS1T6.Null:
answer += "." + str(self._smS1T6)
return answer
def getSm(self):
return self._sm
def getSmS0T1(self):
return self._smS0T1
def getSmS0T2(self):
return self._smS0T2
def getSmS1T4(self):
return self._smS1T4
def getSmS1T6(self):
return self._smS1T6
def goS1(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS0T1 = self._smS0T1
if aSmS0T1 is __class__.SmS0T1.t1:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def goT3(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS0T2 = self._smS0T2
if aSmS0T2 is __class__.SmS0T2.t2:
self.exitSmS0T2()
if self._deleted:
return True
self.setSmS0T2(__class__.SmS0T2.t3)
wasEventProcessed = True
return wasEventProcessed
def goT5(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1T4 = self._smS1T4
if aSmS1T4 is __class__.SmS1T4.t4:
self.exitSmS1T4()
if self._deleted:
return True
self.setSmS1T4(__class__.SmS1T4.t5)
wasEventProcessed = True
return wasEventProcessed
def goT7(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1T6 = self._smS1T6
if aSmS1T6 is __class__.SmS1T6.t6:
self.exitSmS1T6()
if self._deleted:
return True
self.setSmS1T6(__class__.SmS1T6.t7)
wasEventProcessed = True
return wasEventProcessed
def exitSm(self):
self._smVisit += 1
if self._sm is __class__.Sm.s0:
self.exitSmS0T1()
if self._deleted:
return
self.exitSmS0T2()
elif self._sm is __class__.Sm.s1:
self.exitSmS1T4()
if self._deleted:
return
self.exitSmS1T6()
def setSm(self, aSm):
self._sm = aSm
self._smVisit += 1
visit = self._smVisit
if self._sm is __class__.Sm.s0:
if self._smS0T1 is __class__.SmS0T1.Null:
self.setSmS0T1(__class__.SmS0T1.t1)
if self._deleted or self._smVisit != visit:
return
if self._smS0T2 is __class__.SmS0T2.Null:
self.setSmS0T2(__class__.SmS0T2.t2)
elif self._sm is __class__.Sm.s1:
if self._smS1T4 is __class__.SmS1T4.Null:
self.setSmS1T4(__class__.SmS1T4.t4)
if self._deleted or self._smVisit != visit:
return
if self._smS1T6 is __class__.SmS1T6.Null:
self.setSmS1T6(__class__.SmS1T6.t6)
def exitSmS0T1(self):
if self._smS0T1 is __class__.SmS0T1.t1:
self.setSmS0T1(__class__.SmS0T1.Null)
def setSmS0T1(self, aSmS0T1):
self._smS0T1 = aSmS0T1
if self._sm is not __class__.Sm.s0 and aSmS0T1 is not __class__.SmS0T1.Null:
self.setSm(__class__.Sm.s0)
if self._deleted:
return
def exitSmS0T2(self):
self._smS0T2Visit += 1
if self._smS0T2 is __class__.SmS0T2.t2:
self.t2_exit_action()
if self._deleted:
return
self.setSmS0T2(__class__.SmS0T2.Null)
elif self._smS0T2 is __class__.SmS0T2.t3:
self.setSmS0T2(__class__.SmS0T2.Null)
def setSmS0T2(self, aSmS0T2):
self._smS0T2 = aSmS0T2
self._smS0T2Visit += 1
visit = self._smS0T2Visit
if self._sm is not __class__.Sm.s0 and aSmS0T2 is not __class__.SmS0T2.Null:
self.setSm(__class__.Sm.s0)
if self._deleted or self._smS0T2Visit != visit:
return
if self._smS0T2 is __class__.SmS0T2.t2:
self.t2_entry_action()
if self._deleted:
return
def exitSmS1T4(self):
if self._smS1T4 is __class__.SmS1T4.t4:
self.setSmS1T4(__class__.SmS1T4.Null)
elif self._smS1T4 is __class__.SmS1T4.t5:
self.setSmS1T4(__class__.SmS1T4.Null)
def setSmS1T4(self, aSmS1T4):
self._smS1T4 = aSmS1T4
if self._sm is not __class__.Sm.s1 and aSmS1T4 is not __class__.SmS1T4.Null:
self.setSm(__class__.Sm.s1)
if self._deleted:
return
def exitSmS1T6(self):
self._smS1T6Visit += 1
if self._smS1T6 is __class__.SmS1T6.t6:
self.t6_exit_action()
if self._deleted:
return
self.setSmS1T6(__class__.SmS1T6.Null)
elif self._smS1T6 is __class__.SmS1T6.t7:
self.setSmS1T6(__class__.SmS1T6.Null)
def setSmS1T6(self, aSmS1T6):
self._smS1T6 = aSmS1T6
self._smS1T6Visit += 1
visit = self._smS1T6Visit
if self._sm is not __class__.Sm.s1 and aSmS1T6 is not __class__.SmS1T6.Null:
self.setSm(__class__.Sm.s1)
if self._deleted or self._smS1T6Visit != visit:
return
if self._smS1T6 is __class__.SmS1T6.t6:
self.t6_entry_action()
if self._deleted:
return
def delete(self):
self._deleted = True
def t2_entry_action(self):
pass
def t6_entry_action(self):
pass
def t2_exit_action(self):
pass
def t6_exit_action(self):
pass
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class QSMwithUnspecifiedRecep:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
error1 = "error1"
error2 = "error2"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __init__(self):
self.__eventQueue = __class__.MessageQueue(None)
self._sm = None
self._deleted = False
self.setSm(__class__.Sm.s1)
if self._deleted:
return
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
return answer
def getSm(self):
return self._sm
def _e1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
else:
wasEventProcessed = self.unspecified(self.getSm().value, "e1") or wasEventProcessed
return wasEventProcessed
def e1(self):
self.__eventQueue.put(self._e1)
def unspecified(self, state, event):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.printError()
if self._deleted:
return True
self.setSm(__class__.Sm.error1)
wasEventProcessed = True
elif aSm is __class__.Sm.s2:
self.setSm(__class__.Sm.error2)
wasEventProcessed = True
return wasEventProcessed
def _e2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
else:
wasEventProcessed = self.unspecified(self.getSm().value, "e2") or wasEventProcessed
return wasEventProcessed
def e2(self):
self.__eventQueue.put(self._e2)
def __autotransition1__(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.error1:
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def __autotransition2__(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.error2:
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def setSm(self, aSm):
self._sm = aSm
if self._sm is __class__.Sm.error1:
self.__autotransition1__()
elif self._sm is __class__.Sm.error2:
self.__autotransition2__()
def delete(self):
self._deleted = True
self.__eventQueue.stop()
def printError(self):
# line 21 "stateMachine_unSpecifiedReception_QSMPython.ump"
print("Unspecified Reception")
# end line
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class Lamp:
"""A do activity in each of two states of one machine"""
class Status(Enum):
On = "On"
Off = "Off"
def __str__(self):
return self.value
class DoActivityThread(threading.Thread):
def __init__(self, controller, doActivityMethodName):
super().__init__(daemon=False)
self._controller = controller
self._doActivityMethodName = doActivityMethodName
self._siblings = ()
self.cancelled = threading.Event()
def sleep(self, milliseconds):
if milliseconds < 0:
raise ValueError("timeout value is negative")
return self.cancelled.wait(milliseconds / 1000)
@staticmethod
def startAll(*workers):
for worker in workers:
worker._siblings = tuple(other for other in workers if other is not worker)
for worker in workers:
if worker._controller._deleted or worker.cancelled.is_set():
return
worker.start()
def run(self):
controller = self._controller
if self._doActivityMethodName == "doActivityStatusOn":
controller.doActivityStatusOn(self)
elif self._doActivityMethodName == "doActivityStatusOff":
controller.doActivityStatusOff(self)
def __init__(self):
self._status = None
self._doActivityStatusOnThread = None
self._doActivityStatusOffThread = None
self._deleted = False
self.setStatus(__class__.Status.On)
if self._deleted:
return
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def press(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.On:
self.exitStatus()
if self._deleted:
return True
self.setStatus(__class__.Status.Off)
wasEventProcessed = True
elif aStatus is __class__.Status.Off:
self.exitStatus()
if self._deleted:
return True
self.setStatus(__class__.Status.On)
wasEventProcessed = True
return wasEventProcessed
def exitStatus(self):
if self._status is __class__.Status.On:
if self._doActivityStatusOnThread is not None:
self._doActivityStatusOnThread.cancelled.set()
elif self._status is __class__.Status.Off:
if self._doActivityStatusOffThread is not None:
self._doActivityStatusOffThread.cancelled.set()
def setStatus(self, aStatus):
self._status = aStatus
if self._status is __class__.Status.On:
self._doActivityStatusOnThread = __class__.DoActivityThread(self, "doActivityStatusOn")
__class__.DoActivityThread.startAll(self._doActivityStatusOnThread)
elif self._status is __class__.Status.Off:
self._doActivityStatusOffThread = __class__.DoActivityThread(self, "doActivityStatusOff")
__class__.DoActivityThread.startAll(self._doActivityStatusOffThread)
def doActivityStatusOn(self, thread):
# line 12 "../doActivityMultiplePython.ump"
self.alsoDo()
# end line
def doActivityStatusOff(self, thread):
# line 18 "../doActivityMultiplePython.ump"
self.keepDoing()
# end line
def delete(self):
self._deleted = True
if self._doActivityStatusOnThread is not None:
self._doActivityStatusOnThread.cancelled.set()
if self._doActivityStatusOffThread is not None:
self._doActivityStatusOffThread.cancelled.set()
def alsoDo(self):
# line 21 "../doActivityMultiplePython.ump"
pass
# end line
def keepDoing(self):
# line 22 "../doActivityMultiplePython.ump"
pass
# end line
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class X:
class Sm(Enum):
on = "on"
off = "off"
def __str__(self):
return self.value
class SmOn(Enum):
Null = "Null"
s1 = "s1"
s2 = "s2"
def __str__(self):
return self.value
class SmOnS1(Enum):
Null = "Null"
m1 = "m1"
m2 = "m2"
def __str__(self):
return self.value
def __init__(self):
self._sm = None
self._smOn = None
self._smOnVisit = 0
self._smOnS1 = None
self._deleted = False
self.setSmOn(__class__.SmOn.Null)
if self._deleted:
return
self.setSmOnS1(__class__.SmOnS1.Null)
if self._deleted:
return
self.setSm(__class__.Sm.on)
if self._deleted:
return
def getSmFullName(self):
answer = str(self._sm)
if self._smOn is not __class__.SmOn.Null:
answer += "." + str(self._smOn)
if self._smOnS1 is not __class__.SmOnS1.Null:
answer += "." + str(self._smOnS1)
return answer
def getSm(self):
return self._sm
def getSmOn(self):
return self._smOn
def getSmOnS1(self):
return self._smOnS1
def e1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.on:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.off)
wasEventProcessed = True
return wasEventProcessed
def e2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.on:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.on)
wasEventProcessed = True
return wasEventProcessed
def e3(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOn = self._smOn
if aSmOn is __class__.SmOn.s1:
self.exitSmOn()
if self._deleted:
return True
self.setSmOn(__class__.SmOn.s2)
wasEventProcessed = True
return wasEventProcessed
def e4(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOn = self._smOn
if aSmOn is __class__.SmOn.s1:
self.exitSmOn()
if self._deleted:
return True
self.setSmOn(__class__.SmOn.s1)
wasEventProcessed = True
return wasEventProcessed
def e5(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOn = self._smOn
if aSmOn is __class__.SmOn.s1:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.on)
wasEventProcessed = True
return wasEventProcessed
def e6(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOn = self._smOn
if aSmOn is __class__.SmOn.s1:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.off)
wasEventProcessed = True
return wasEventProcessed
def e7(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOnS1 = self._smOnS1
if aSmOnS1 is __class__.SmOnS1.m1:
self.exitSmOnS1()
if self._deleted:
return True
self.setSmOnS1(__class__.SmOnS1.m2)
wasEventProcessed = True
return wasEventProcessed
def e8(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOnS1 = self._smOnS1
if aSmOnS1 is __class__.SmOnS1.m1:
self.exitSmOnS1()
if self._deleted:
return True
self.setSmOnS1(__class__.SmOnS1.m1)
wasEventProcessed = True
return wasEventProcessed
def e9(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOnS1 = self._smOnS1
if aSmOnS1 is __class__.SmOnS1.m1:
self.exitSmOn()
if self._deleted:
return True
self.setSmOn(__class__.SmOn.s1)
wasEventProcessed = True
return wasEventProcessed
def e10(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOnS1 = self._smOnS1
if aSmOnS1 is __class__.SmOnS1.m1:
self.exitSmOn()
if self._deleted:
return True
self.setSmOn(__class__.SmOn.s2)
wasEventProcessed = True
return wasEventProcessed
def e11(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOnS1 = self._smOnS1
if aSmOnS1 is __class__.SmOnS1.m1:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.on)
wasEventProcessed = True
return wasEventProcessed
def e12(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOnS1 = self._smOnS1
if aSmOnS1 is __class__.SmOnS1.m1:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.off)
wasEventProcessed = True
return wasEventProcessed
def exitSm(self):
if self._sm is __class__.Sm.on:
self.exitSmOn()
if self._deleted:
return
self.on_exit_action()
def setSm(self, aSm):
self._sm = aSm
if self._sm is __class__.Sm.on:
if self._smOn is __class__.SmOn.Null:
self.setSmOn(__class__.SmOn.s1)
def exitSmOn(self):
self._smOnVisit += 1
if self._smOn is __class__.SmOn.s1:
self.exitSmOnS1()
if self._deleted:
return
self.s1_exit_action()
if self._deleted:
return
self.setSmOn(__class__.SmOn.Null)
elif self._smOn is __class__.SmOn.s2:
self.setSmOn(__class__.SmOn.Null)
def setSmOn(self, aSmOn):
self._smOn = aSmOn
self._smOnVisit += 1
visit = self._smOnVisit
if self._sm is not __class__.Sm.on and aSmOn is not __class__.SmOn.Null:
self.setSm(__class__.Sm.on)
if self._deleted or self._smOnVisit != visit:
return
if self._smOn is __class__.SmOn.s1:
if self._smOnS1 is __class__.SmOnS1.Null:
self.setSmOnS1(__class__.SmOnS1.m1)
def exitSmOnS1(self):
if self._smOnS1 is __class__.SmOnS1.m1:
self.m1_exit_action()
if self._deleted:
return
self.setSmOnS1(__class__.SmOnS1.Null)
elif self._smOnS1 is __class__.SmOnS1.m2:
self.setSmOnS1(__class__.SmOnS1.Null)
def setSmOnS1(self, aSmOnS1):
self._smOnS1 = aSmOnS1
if self._smOn is not __class__.SmOn.s1 and aSmOnS1 is not __class__.SmOnS1.Null:
self.setSmOn(__class__.SmOn.s1)
if self._deleted:
return
def delete(self):
self._deleted = True
def on_exit_action(self):
# line 28 "checkExternalTransitions_withExitActions_1Python.ump"
print("exited on")
# end line
def s1_exit_action(self):
# line 29 "checkExternalTransitions_withExitActions_1Python.ump"
print("exited s1")
# end line
def m1_exit_action(self):
# line 30 "checkExternalTransitions_withExitActions_1Python.ump"
print("exited m1")
# end line
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class A:
class Status(Enum):
s1 = "s1"
s2 = "s2"
def __str__(self):
return self.value
def __init__(self):
self._repeatCheck = False
self._status = None
self._statusVisit = 0
self._deleted = False
self.setStatus(__class__.Status.s1)
if self._deleted:
return
def setRepeatCheck(self, aRepeatCheck):
self._repeatCheck = aRepeatCheck
return True
def getRepeatCheck(self):
return self._repeatCheck
def isRepeatCheck(self):
return self._repeatCheck
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def __autotransition1__(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
visit = self._statusVisit
if aStatus is __class__.Status.s1:
guard = self.getRepeatCheck() != self.repeatCheck()
if self._deleted:
return True
if self._statusVisit != visit:
return wasEventProcessed
if guard:
self.setStatus(__class__.Status.s2)
wasEventProcessed = True
return wasEventProcessed
def setStatus(self, aStatus):
self._status = aStatus
self._statusVisit += 1
if self._status is __class__.Status.s1:
self.__autotransition1__()
def delete(self):
self._deleted = True
def repeatCheck(self):
# line 11 "guardNameBothAttributeAndMethod3Python.ump"
return True
# end line
def __str__(self):
return (super().__str__() + "["
+ "repeatCheck:" + str(self.getRepeatCheck())
+ "]")
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class X:
class Sm(Enum):
on = "on"
idle = "idle"
off = "off"
def __str__(self):
return self.value
def __init__(self):
self._sm = None
self._deleted = False
self.setSm(__class__.Sm.on)
def getSmFullName(self):
answer = str(self._sm)
return answer
def getSm(self):
return self._sm
def turnOff(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.on:
self.setSm(__class__.Sm.off)
wasEventProcessed = True
return wasEventProcessed
def goIdle(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.on:
self.setSm(__class__.Sm.idle)
wasEventProcessed = True
return wasEventProcessed
def buttonPressed(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.idle:
self.setSm(__class__.Sm.on)
wasEventProcessed = True
return wasEventProcessed
def turnOn(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.off:
self.setSm(__class__.Sm.on)
wasEventProcessed = True
return wasEventProcessed
def setSm(self, aSm):
self._sm = aSm
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class LightFixture:
class Bulb(Enum):
Off = "Off"
On = "On"
def __str__(self):
return self.value
class BulbOn(Enum):
Null = "Null"
Normal = "Normal"
Dimmed = "Dimmed"
def __str__(self):
return self.value
def __init__(self):
self._bulb = None
self._bulbOn = None
self._deleted = False
self.setBulbOn(__class__.BulbOn.Null)
if self._deleted:
return
self.setBulb(__class__.Bulb.Off)
if self._deleted:
return
def getBulbFullName(self):
answer = str(self._bulb)
if self._bulbOn is not __class__.BulbOn.Null:
answer += "." + str(self._bulbOn)
return answer
def getBulb(self):
return self._bulb
def getBulbOn(self):
return self._bulbOn
def flip(self):
if self._deleted:
return False
wasEventProcessed = False
aBulb = self._bulb
if aBulb is __class__.Bulb.Off:
self.setBulb(__class__.Bulb.On)
wasEventProcessed = True
elif aBulb is __class__.Bulb.On:
self.exitBulb()
if self._deleted:
return True
self.setBulb(__class__.Bulb.Off)
wasEventProcessed = True
return wasEventProcessed
def touch(self):
if self._deleted:
return False
wasEventProcessed = False
aBulbOn = self._bulbOn
if aBulbOn is __class__.BulbOn.Normal:
self.exitBulbOn()
if self._deleted:
return True
self.setBulbOn(__class__.BulbOn.Dimmed)
wasEventProcessed = True
elif aBulbOn is __class__.BulbOn.Dimmed:
self.exitBulb()
if self._deleted:
return True
self.setBulb(__class__.Bulb.Off)
wasEventProcessed = True
return wasEventProcessed
def exitBulb(self):
if self._bulb is __class__.Bulb.On:
self.exitBulbOn()
if self._deleted:
return
print("Show Me Last (Exit)")
def setBulb(self, aBulb):
self._bulb = aBulb
if self._bulb is __class__.Bulb.On:
if self._bulbOn is __class__.BulbOn.Null:
self.setBulbOn(__class__.BulbOn.Normal)
def exitBulbOn(self):
if self._bulbOn is __class__.BulbOn.Normal:
self.setBulbOn(__class__.BulbOn.Null)
elif self._bulbOn is __class__.BulbOn.Dimmed:
self.setBulbOn(__class__.BulbOn.Null)
def setBulbOn(self, aBulbOn):
self._bulbOn = aBulbOn
if self._bulb is not __class__.Bulb.On and aBulbOn is not __class__.BulbOn.Null:
self.setBulb(__class__.Bulb.On)
if self._deleted:
return
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class LightFixture:
class Bulb(Enum):
On = "On"
Off = "Off"
def __str__(self):
return self.value
class AnotherBulb(Enum):
On = "On"
Amber = "Amber"
def __str__(self):
return self.value
def __init__(self):
self._bulb = None
self._anotherBulb = None
self._deleted = False
self.setBulb(__class__.Bulb.On)
self.setAnotherBulb(__class__.AnotherBulb.On)
def getBulbFullName(self):
answer = str(self._bulb)
return answer
def getAnotherBulbFullName(self):
answer = str(self._anotherBulb)
return answer
def getBulb(self):
return self._bulb
def getAnotherBulb(self):
return self._anotherBulb
def flip(self):
if self._deleted:
return False
wasEventProcessed = False
aBulb = self._bulb
aAnotherBulb = self._anotherBulb
if aBulb is __class__.Bulb.On:
self.setBulb(__class__.Bulb.Off)
wasEventProcessed = True
elif aBulb is __class__.Bulb.Off:
self.setBulb(__class__.Bulb.On)
wasEventProcessed = True
if aAnotherBulb is __class__.AnotherBulb.On:
self.setAnotherBulb(__class__.AnotherBulb.Amber)
wasEventProcessed = True
return wasEventProcessed
def unflip(self):
if self._deleted:
return False
wasEventProcessed = False
aAnotherBulb = self._anotherBulb
if aAnotherBulb is __class__.AnotherBulb.Amber:
self.setAnotherBulb(__class__.AnotherBulb.On)
wasEventProcessed = True
return wasEventProcessed
def setBulb(self, aBulb):
self._bulb = aBulb
def setAnotherBulb(self, aAnotherBulb):
self._anotherBulb = aAnotherBulb
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class X:
class Sm(Enum):
s0 = "s0"
s1 = "s1"
def __str__(self):
return self.value
class SmS0T1(Enum):
Null = "Null"
t1 = "t1"
def __str__(self):
return self.value
class SmS0T2(Enum):
Null = "Null"
t2 = "t2"
t3 = "t3"
def __str__(self):
return self.value
class SmS1T1(Enum):
Null = "Null"
t1 = "t1"
t4 = "t4"
def __str__(self):
return self.value
class SmS1T2(Enum):
Null = "Null"
t2 = "t2"
t5 = "t5"
def __str__(self):
return self.value
def __init__(self):
self._sm = None
self._smVisit = 0
self._smS0T1 = None
self._smS0T1Visit = 0
self._smS0T2 = None
self._smS0T2Visit = 0
self._smS1T1 = None
self._smS1T1Visit = 0
self._smS1T2 = None
self._smS1T2Visit = 0
self._deleted = False
self.setSmS0T1(__class__.SmS0T1.Null)
if self._deleted:
return
self.setSmS0T2(__class__.SmS0T2.Null)
if self._deleted:
return
self.setSmS1T1(__class__.SmS1T1.Null)
if self._deleted:
return
self.setSmS1T2(__class__.SmS1T2.Null)
if self._deleted:
return
self.setSm(__class__.Sm.s0)
if self._deleted:
return
def getSmFullName(self):
answer = str(self._sm)
if self._smS0T1 is not __class__.SmS0T1.Null:
answer += "." + str(self._smS0T1)
if self._smS0T2 is not __class__.SmS0T2.Null:
answer += "." + str(self._smS0T2)
if self._smS1T1 is not __class__.SmS1T1.Null:
answer += "." + str(self._smS1T1)
if self._smS1T2 is not __class__.SmS1T2.Null:
answer += "." + str(self._smS1T2)
return answer
def getSm(self):
return self._sm
def getSmS0T1(self):
return self._smS0T1
def getSmS0T2(self):
return self._smS0T2
def getSmS1T1(self):
return self._smS1T1
def getSmS1T2(self):
return self._smS1T2
def goS1(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS0T1 = self._smS0T1
if aSmS0T1 is __class__.SmS0T1.t1:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def goT3(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS0T2 = self._smS0T2
if aSmS0T2 is __class__.SmS0T2.t2:
self.exitSmS0T2()
if self._deleted:
return True
self.setSmS0T2(__class__.SmS0T2.t3)
wasEventProcessed = True
return wasEventProcessed
def goT4(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1T1 = self._smS1T1
if aSmS1T1 is __class__.SmS1T1.t1:
self.exitSmS1T1()
if self._deleted:
return True
self.setSmS1T1(__class__.SmS1T1.t4)
wasEventProcessed = True
return wasEventProcessed
def goT5(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1T2 = self._smS1T2
if aSmS1T2 is __class__.SmS1T2.t2:
self.exitSmS1T2()
if self._deleted:
return True
self.setSmS1T2(__class__.SmS1T2.t5)
wasEventProcessed = True
return wasEventProcessed
def exitSm(self):
self._smVisit += 1
if self._sm is __class__.Sm.s0:
self.exitSmS0T1()
if self._deleted:
return
self.exitSmS0T2()
elif self._sm is __class__.Sm.s1:
self.exitSmS1T1()
if self._deleted:
return
self.exitSmS1T2()
def setSm(self, aSm):
self._sm = aSm
self._smVisit += 1
visit = self._smVisit
if self._sm is __class__.Sm.s0:
if self._smS0T1 is __class__.SmS0T1.Null:
self.setSmS0T1(__class__.SmS0T1.t1)
if self._deleted or self._smVisit != visit:
return
if self._smS0T2 is __class__.SmS0T2.Null:
self.setSmS0T2(__class__.SmS0T2.t2)
elif self._sm is __class__.Sm.s1:
if self._smS1T1 is __class__.SmS1T1.Null:
self.setSmS1T1(__class__.SmS1T1.t1)
if self._deleted or self._smVisit != visit:
return
if self._smS1T2 is __class__.SmS1T2.Null:
self.setSmS1T2(__class__.SmS1T2.t2)
def exitSmS0T1(self):
self._smS0T1Visit += 1
if self._smS0T1 is __class__.SmS0T1.t1:
self.s0_t1_exit()
if self._deleted:
return
self.setSmS0T1(__class__.SmS0T1.Null)
def setSmS0T1(self, aSmS0T1):
self._smS0T1 = aSmS0T1
self._smS0T1Visit += 1
visit = self._smS0T1Visit
if self._sm is not __class__.Sm.s0 and aSmS0T1 is not __class__.SmS0T1.Null:
self.setSm(__class__.Sm.s0)
if self._deleted or self._smS0T1Visit != visit:
return
if self._smS0T1 is __class__.SmS0T1.t1:
self.s0_t1_entry()
if self._deleted:
return
def exitSmS0T2(self):
self._smS0T2Visit += 1
if self._smS0T2 is __class__.SmS0T2.t2:
self.s0_t2_exit()
if self._deleted:
return
self.setSmS0T2(__class__.SmS0T2.Null)
elif self._smS0T2 is __class__.SmS0T2.t3:
self.setSmS0T2(__class__.SmS0T2.Null)
def setSmS0T2(self, aSmS0T2):
self._smS0T2 = aSmS0T2
self._smS0T2Visit += 1
visit = self._smS0T2Visit
if self._sm is not __class__.Sm.s0 and aSmS0T2 is not __class__.SmS0T2.Null:
self.setSm(__class__.Sm.s0)
if self._deleted or self._smS0T2Visit != visit:
return
if self._smS0T2 is __class__.SmS0T2.t2:
self.s0_t2_entry()
if self._deleted:
return
def exitSmS1T1(self):
self._smS1T1Visit += 1
if self._smS1T1 is __class__.SmS1T1.t1:
self.s1_t1_exit()
if self._deleted:
return
self.setSmS1T1(__class__.SmS1T1.Null)
elif self._smS1T1 is __class__.SmS1T1.t4:
self.setSmS1T1(__class__.SmS1T1.Null)
def setSmS1T1(self, aSmS1T1):
self._smS1T1 = aSmS1T1
self._smS1T1Visit += 1
visit = self._smS1T1Visit
if self._sm is not __class__.Sm.s1 and aSmS1T1 is not __class__.SmS1T1.Null:
self.setSm(__class__.Sm.s1)
if self._deleted or self._smS1T1Visit != visit:
return
if self._smS1T1 is __class__.SmS1T1.t1:
self.s1_t1_entry()
if self._deleted:
return
def exitSmS1T2(self):
self._smS1T2Visit += 1
if self._smS1T2 is __class__.SmS1T2.t2:
self.s1_t2_exit()
if self._deleted:
return
self.setSmS1T2(__class__.SmS1T2.Null)
elif self._smS1T2 is __class__.SmS1T2.t5:
self.setSmS1T2(__class__.SmS1T2.Null)
def setSmS1T2(self, aSmS1T2):
self._smS1T2 = aSmS1T2
self._smS1T2Visit += 1
visit = self._smS1T2Visit
if self._sm is not __class__.Sm.s1 and aSmS1T2 is not __class__.SmS1T2.Null:
self.setSm(__class__.Sm.s1)
if self._deleted or self._smS1T2Visit != visit:
return
if self._smS1T2 is __class__.SmS1T2.t2:
self.s1_t2_entry()
if self._deleted:
return
def delete(self):
self._deleted = True
def s0_t1_entry(self):
pass
def s0_t2_entry(self):
pass
def s1_t1_entry(self):
pass
def s1_t2_entry(self):
pass
def s0_t1_exit(self):
pass
def s0_t2_exit(self):
pass
def s1_t1_exit(self):
pass
def s1_t2_exit(self):
pass
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class A:
class Status(Enum):
s1 = "s1"
s2 = "s2"
s3 = "s3"
def __str__(self):
return self.value
def __init__(self):
self._repeatCheck = False
self._status = None
self._statusVisit = 0
self._deleted = False
self.setStatus(__class__.Status.s1)
if self._deleted:
return
def setRepeatCheck(self, aRepeatCheck):
self._repeatCheck = aRepeatCheck
return True
def getRepeatCheck(self):
return self._repeatCheck
def isRepeatCheck(self):
return self._repeatCheck
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def __autotransition1__(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
visit = self._statusVisit
if aStatus is __class__.Status.s1:
guard = self.repeatCheck()
if self._deleted:
return True
if self._statusVisit != visit:
return wasEventProcessed
if guard:
self.setStatus(__class__.Status.s2)
wasEventProcessed = True
return wasEventProcessed
def setStatus(self, aStatus):
self._status = aStatus
self._statusVisit += 1
if self._status is __class__.Status.s1:
self.__autotransition1__()
def delete(self):
self._deleted = True
def repeatCheck(self):
# line 15 "guardNameBothAttributeAndMethodPython.ump"
return True
# end line
def __str__(self):
return (super().__str__() + "["
+ "repeatCheck:" + str(self.getRepeatCheck())
+ "]")
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class X:
class Sm(Enum):
on = "on"
off = "off"
def __str__(self):
return self.value
class SmOn(Enum):
Null = "Null"
s1 = "s1"
s2 = "s2"
def __str__(self):
return self.value
class SmOnS1(Enum):
Null = "Null"
m1 = "m1"
m2 = "m2"
def __str__(self):
return self.value
class SmOff(Enum):
Null = "Null"
s3 = "s3"
s4 = "s4"
def __str__(self):
return self.value
def __init__(self):
self._sm = None
self._smVisit = 0
self._smOn = None
self._smOnVisit = 0
self._smOnS1 = None
self._smOnS1Visit = 0
self._smOff = None
self._deleted = False
self.setSmOn(__class__.SmOn.Null)
if self._deleted:
return
self.setSmOnS1(__class__.SmOnS1.Null)
if self._deleted:
return
self.setSmOff(__class__.SmOff.Null)
if self._deleted:
return
self.setSm(__class__.Sm.on)
if self._deleted:
return
def getSmFullName(self):
answer = str(self._sm)
if self._smOn is not __class__.SmOn.Null:
answer += "." + str(self._smOn)
if self._smOnS1 is not __class__.SmOnS1.Null:
answer += "." + str(self._smOnS1)
if self._smOff is not __class__.SmOff.Null:
answer += "." + str(self._smOff)
return answer
def getSm(self):
return self._sm
def getSmOn(self):
return self._smOn
def getSmOnS1(self):
return self._smOnS1
def getSmOff(self):
return self._smOff
def e1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.on:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.off)
wasEventProcessed = True
return wasEventProcessed
def e2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.on:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.on)
wasEventProcessed = True
return wasEventProcessed
def e3(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOn = self._smOn
if aSmOn is __class__.SmOn.s1:
self.exitSmOn()
if self._deleted:
return True
self.setSmOn(__class__.SmOn.s2)
wasEventProcessed = True
return wasEventProcessed
def e4(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOn = self._smOn
if aSmOn is __class__.SmOn.s1:
self.exitSmOn()
if self._deleted:
return True
self.setSmOn(__class__.SmOn.s1)
wasEventProcessed = True
return wasEventProcessed
def e5(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOn = self._smOn
if aSmOn is __class__.SmOn.s1:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.on)
wasEventProcessed = True
return wasEventProcessed
def e6(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOn = self._smOn
if aSmOn is __class__.SmOn.s1:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.off)
wasEventProcessed = True
return wasEventProcessed
def e7(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOnS1 = self._smOnS1
if aSmOnS1 is __class__.SmOnS1.m1:
self.exitSmOnS1()
if self._deleted:
return True
self.setSmOnS1(__class__.SmOnS1.m2)
wasEventProcessed = True
return wasEventProcessed
def e8(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOnS1 = self._smOnS1
if aSmOnS1 is __class__.SmOnS1.m1:
self.exitSmOnS1()
if self._deleted:
return True
self.setSmOnS1(__class__.SmOnS1.m1)
wasEventProcessed = True
return wasEventProcessed
def e9(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOnS1 = self._smOnS1
if aSmOnS1 is __class__.SmOnS1.m1:
self.exitSmOn()
if self._deleted:
return True
self.setSmOn(__class__.SmOn.s1)
wasEventProcessed = True
return wasEventProcessed
def e10(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOnS1 = self._smOnS1
if aSmOnS1 is __class__.SmOnS1.m1:
self.exitSmOn()
if self._deleted:
return True
self.setSmOn(__class__.SmOn.s2)
wasEventProcessed = True
return wasEventProcessed
def e11(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOnS1 = self._smOnS1
if aSmOnS1 is __class__.SmOnS1.m1:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.on)
wasEventProcessed = True
return wasEventProcessed
def e12(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOnS1 = self._smOnS1
if aSmOnS1 is __class__.SmOnS1.m1:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.off)
wasEventProcessed = True
return wasEventProcessed
def e13(self):
if self._deleted:
return False
wasEventProcessed = False
aSmOff = self._smOff
if aSmOff is __class__.SmOff.s3:
self.exitSmOff()
if self._deleted:
return True
self.setSmOff(__class__.SmOff.s4)
wasEventProcessed = True
return wasEventProcessed
def exitSm(self):
self._smVisit += 1
if self._sm is __class__.Sm.on:
self.exitSmOn()
elif self._sm is __class__.Sm.off:
self.exitSmOff()
def setSm(self, aSm):
self._sm = aSm
self._smVisit += 1
visit = self._smVisit
if self._sm is __class__.Sm.on:
self.on_entry_action()
if self._deleted or self._smVisit != visit:
return
if self._smOn is __class__.SmOn.Null:
self.setSmOn(__class__.SmOn.s1)
elif self._sm is __class__.Sm.off:
if self._smOff is __class__.SmOff.Null:
self.setSmOff(__class__.SmOff.s3)
def exitSmOn(self):
self._smOnVisit += 1
if self._smOn is __class__.SmOn.s1:
self.exitSmOnS1()
if self._deleted:
return
self.setSmOn(__class__.SmOn.Null)
elif self._smOn is __class__.SmOn.s2:
self.setSmOn(__class__.SmOn.Null)
def setSmOn(self, aSmOn):
self._smOn = aSmOn
self._smOnVisit += 1
visit = self._smOnVisit
if self._sm is not __class__.Sm.on and aSmOn is not __class__.SmOn.Null:
self.setSm(__class__.Sm.on)
if self._deleted or self._smOnVisit != visit:
return
if self._smOn is __class__.SmOn.s1:
self.s1_entry_action()
if self._deleted or self._smOnVisit != visit:
return
if self._smOnS1 is __class__.SmOnS1.Null:
self.setSmOnS1(__class__.SmOnS1.m1)
def exitSmOnS1(self):
self._smOnS1Visit += 1
if self._smOnS1 is __class__.SmOnS1.m1:
self.setSmOnS1(__class__.SmOnS1.Null)
elif self._smOnS1 is __class__.SmOnS1.m2:
self.setSmOnS1(__class__.SmOnS1.Null)
def setSmOnS1(self, aSmOnS1):
self._smOnS1 = aSmOnS1
self._smOnS1Visit += 1
visit = self._smOnS1Visit
if self._smOn is not __class__.SmOn.s1 and aSmOnS1 is not __class__.SmOnS1.Null:
self.setSmOn(__class__.SmOn.s1)
if self._deleted or self._smOnS1Visit != visit:
return
if self._smOnS1 is __class__.SmOnS1.m1:
self.m1_entry_action()
if self._deleted:
return
def exitSmOff(self):
if self._smOff is __class__.SmOff.s3:
self.setSmOff(__class__.SmOff.Null)
elif self._smOff is __class__.SmOff.s4:
self.setSmOff(__class__.SmOff.Null)
def setSmOff(self, aSmOff):
self._smOff = aSmOff
if self._sm is not __class__.Sm.off and aSmOff is not __class__.SmOff.Null:
self.setSm(__class__.Sm.off)
if self._deleted:
return
def delete(self):
self._deleted = True
def on_entry_action(self):
pass
def s1_entry_action(self):
pass
def m1_entry_action(self):
pass
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class X:
class Sm(Enum):
s1 = "s1"
s4 = "s4"
def __str__(self):
return self.value
class SmS1(Enum):
Null = "Null"
s2 = "s2"
s3 = "s3"
def __str__(self):
return self.value
class SmS4(Enum):
Null = "Null"
s5 = "s5"
def __str__(self):
return self.value
def __init__(self):
self._sm = None
self._smS1 = None
self._smS1Visit = 0
self._smS4 = None
self._smS4Visit = 0
self._deleted = False
self.setSmS1(__class__.SmS1.Null)
if self._deleted:
return
self.setSmS4(__class__.SmS4.Null)
if self._deleted:
return
self.setSm(__class__.Sm.s1)
if self._deleted:
return
def getSmFullName(self):
answer = str(self._sm)
if self._smS1 is not __class__.SmS1.Null:
answer += "." + str(self._smS1)
if self._smS4 is not __class__.SmS4.Null:
answer += "." + str(self._smS4)
return answer
def getSm(self):
return self._sm
def getSmS1(self):
return self._smS1
def getSmS4(self):
return self._smS4
def goToS5(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s4:
self.exitSmS4()
if self._deleted:
return True
self.setSmS4(__class__.SmS4.s5)
wasEventProcessed = True
return wasEventProcessed
def goToS3(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s2:
self.exitSmS1()
if self._deleted:
return True
self.setSmS1(__class__.SmS1.s3)
wasEventProcessed = True
return wasEventProcessed
def goToS4(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s2:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.s4)
wasEventProcessed = True
return wasEventProcessed
def exitSm(self):
if self._sm is __class__.Sm.s1:
self.exitSmS1()
elif self._sm is __class__.Sm.s4:
self.exitSmS4()
def setSm(self, aSm):
self._sm = aSm
if self._sm is __class__.Sm.s1:
if self._smS1 is __class__.SmS1.Null:
self.setSmS1(__class__.SmS1.s2)
elif self._sm is __class__.Sm.s4:
if self._smS4 is __class__.SmS4.Null:
self.setSmS4(__class__.SmS4.s5)
def exitSmS1(self):
self._smS1Visit += 1
if self._smS1 is __class__.SmS1.s2:
self.setSmS1(__class__.SmS1.Null)
elif self._smS1 is __class__.SmS1.s3:
self.setSmS1(__class__.SmS1.Null)
def setSmS1(self, aSmS1):
self._smS1 = aSmS1
self._smS1Visit += 1
visit = self._smS1Visit
if self._sm is not __class__.Sm.s1 and aSmS1 is not __class__.SmS1.Null:
self.setSm(__class__.Sm.s1)
if self._deleted or self._smS1Visit != visit:
return
if self._smS1 is __class__.SmS1.s3:
self.delete()
def exitSmS4(self):
self._smS4Visit += 1
if self._smS4 is __class__.SmS4.s5:
self.setSmS4(__class__.SmS4.Null)
def setSmS4(self, aSmS4):
self._smS4 = aSmS4
self._smS4Visit += 1
visit = self._smS4Visit
if self._sm is not __class__.Sm.s4 and aSmS4 is not __class__.SmS4.Null:
self.setSm(__class__.Sm.s4)
if self._deleted or self._smS4Visit != visit:
return
if self._smS4 is __class__.SmS4.s5:
self.delete()
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class X:
class Sm(Enum):
s1 = "s1"
def __str__(self):
return self.value
class SmS1S2(Enum):
Null = "Null"
s2 = "s2"
def __str__(self):
return self.value
class SmS1S3(Enum):
Null = "Null"
s3 = "s3"
def __str__(self):
return self.value
class SmS1S3S3(Enum):
Null = "Null"
s4 = "s4"
s5 = "s5"
def __str__(self):
return self.value
def __init__(self):
self._sm = None
self._smVisit = 0
self._smS1S2 = None
self._smS1S3 = None
self._smS1S3Visit = 0
self._smS1S3S3 = None
self._deleted = False
self.setSmS1S2(__class__.SmS1S2.Null)
if self._deleted:
return
self.setSmS1S3(__class__.SmS1S3.Null)
if self._deleted:
return
self.setSmS1S3S3(__class__.SmS1S3S3.Null)
if self._deleted:
return
self.setSm(__class__.Sm.s1)
if self._deleted:
return
def getSmFullName(self):
answer = str(self._sm)
if self._smS1S2 is not __class__.SmS1S2.Null:
answer += "." + str(self._smS1S2)
if self._smS1S3 is not __class__.SmS1S3.Null:
answer += "." + str(self._smS1S3)
if self._smS1S3S3 is not __class__.SmS1S3S3.Null:
answer += "." + str(self._smS1S3S3)
return answer
def getSm(self):
return self._sm
def getSmS1S2(self):
return self._smS1S2
def getSmS1S3(self):
return self._smS1S3
def getSmS1S3S3(self):
return self._smS1S3S3
def goToS3(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1S2 = self._smS1S2
if aSmS1S2 is __class__.SmS1S2.s2:
self.exitSmS1S2()
if self._deleted:
return True
self.setSmS1S3(__class__.SmS1S3.s3)
if self._deleted:
return True
self.setSmS1S2(__class__.SmS1S2.s2)
wasEventProcessed = True
return wasEventProcessed
def goToS5(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1S3S3 = self._smS1S3S3
if aSmS1S3S3 is __class__.SmS1S3S3.s4:
self.exitSmS1S3S3()
if self._deleted:
return True
self.setSmS1S3S3(__class__.SmS1S3S3.s5)
wasEventProcessed = True
return wasEventProcessed
def exitSm(self):
self._smVisit += 1
if self._sm is __class__.Sm.s1:
self.exitSmS1S2()
if self._deleted:
return
self.exitSmS1S3()
def setSm(self, aSm):
self._sm = aSm
self._smVisit += 1
visit = self._smVisit
if self._sm is __class__.Sm.s1:
if self._smS1S2 is __class__.SmS1S2.Null:
self.setSmS1S2(__class__.SmS1S2.s2)
if self._deleted or self._smVisit != visit:
return
if self._smS1S3 is __class__.SmS1S3.Null:
self.setSmS1S3(__class__.SmS1S3.s3)
def exitSmS1S2(self):
if self._smS1S2 is __class__.SmS1S2.s2:
self.setSmS1S2(__class__.SmS1S2.Null)
def setSmS1S2(self, aSmS1S2):
self._smS1S2 = aSmS1S2
if self._sm is not __class__.Sm.s1 and aSmS1S2 is not __class__.SmS1S2.Null:
self.setSm(__class__.Sm.s1)
if self._deleted:
return
def exitSmS1S3(self):
self._smS1S3Visit += 1
if self._smS1S3 is __class__.SmS1S3.s3:
self.exitSmS1S3S3()
if self._deleted:
return
self.setSmS1S3(__class__.SmS1S3.Null)
def setSmS1S3(self, aSmS1S3):
self._smS1S3 = aSmS1S3
self._smS1S3Visit += 1
visit = self._smS1S3Visit
if self._sm is not __class__.Sm.s1 and aSmS1S3 is not __class__.SmS1S3.Null:
self.setSm(__class__.Sm.s1)
if self._deleted or self._smS1S3Visit != visit:
return
if self._smS1S3 is __class__.SmS1S3.s3:
if self._smS1S3S3 is __class__.SmS1S3S3.Null:
self.setSmS1S3S3(__class__.SmS1S3S3.s4)
def exitSmS1S3S3(self):
if self._smS1S3S3 is __class__.SmS1S3S3.s4:
self.setSmS1S3S3(__class__.SmS1S3S3.Null)
elif self._smS1S3S3 is __class__.SmS1S3S3.s5:
self.setSmS1S3S3(__class__.SmS1S3S3.Null)
def setSmS1S3S3(self, aSmS1S3S3):
self._smS1S3S3 = aSmS1S3S3
if self._smS1S3 is not __class__.SmS1S3.s3 and aSmS1S3S3 is not __class__.SmS1S3S3.Null:
self.setSmS1S3(__class__.SmS1S3.s3)
if self._deleted:
return
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class X:
class Sm(Enum):
s1 = "s1"
def __str__(self):
return self.value
class SmS1S2(Enum):
Null = "Null"
s2 = "s2"
def __str__(self):
return self.value
class SmS1S2S2(Enum):
Null = "Null"
s3 = "s3"
s4 = "s4"
def __str__(self):
return self.value
class SmS1S5(Enum):
Null = "Null"
s5 = "s5"
def __str__(self):
return self.value
class SmS1S5S5(Enum):
Null = "Null"
s6 = "s6"
s7 = "s7"
def __str__(self):
return self.value
class SmS1S8(Enum):
Null = "Null"
s8 = "s8"
def __str__(self):
return self.value
class SmS1S8S8(Enum):
Null = "Null"
s9 = "s9"
s10 = "s10"
def __str__(self):
return self.value
def __init__(self):
self._sm = None
self._smVisit = 0
self._smS1S2 = None
self._smS1S2Visit = 0
self._smS1S2S2 = None
self._smS1S2S2Visit = 0
self._smS1S5 = None
self._smS1S5Visit = 0
self._smS1S5S5 = None
self._smS1S5S5Visit = 0
self._smS1S8 = None
self._smS1S8Visit = 0
self._smS1S8S8 = None
self._smS1S8S8Visit = 0
self._deleted = False
self.setSmS1S2(__class__.SmS1S2.Null)
if self._deleted:
return
self.setSmS1S2S2(__class__.SmS1S2S2.Null)
if self._deleted:
return
self.setSmS1S5(__class__.SmS1S5.Null)
if self._deleted:
return
self.setSmS1S5S5(__class__.SmS1S5S5.Null)
if self._deleted:
return
self.setSmS1S8(__class__.SmS1S8.Null)
if self._deleted:
return
self.setSmS1S8S8(__class__.SmS1S8S8.Null)
if self._deleted:
return
self.setSm(__class__.Sm.s1)
if self._deleted:
return
def getSmFullName(self):
answer = str(self._sm)
if self._smS1S2 is not __class__.SmS1S2.Null:
answer += "." + str(self._smS1S2)
if self._smS1S2S2 is not __class__.SmS1S2S2.Null:
answer += "." + str(self._smS1S2S2)
if self._smS1S5 is not __class__.SmS1S5.Null:
answer += "." + str(self._smS1S5)
if self._smS1S5S5 is not __class__.SmS1S5S5.Null:
answer += "." + str(self._smS1S5S5)
if self._smS1S8 is not __class__.SmS1S8.Null:
answer += "." + str(self._smS1S8)
if self._smS1S8S8 is not __class__.SmS1S8S8.Null:
answer += "." + str(self._smS1S8S8)
return answer
def getSm(self):
return self._sm
def getSmS1S2(self):
return self._smS1S2
def getSmS1S2S2(self):
return self._smS1S2S2
def getSmS1S5(self):
return self._smS1S5
def getSmS1S5S5(self):
return self._smS1S5S5
def getSmS1S8(self):
return self._smS1S8
def getSmS1S8S8(self):
return self._smS1S8S8
def goToS4(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1S2S2 = self._smS1S2S2
if aSmS1S2S2 is __class__.SmS1S2S2.s3:
self.exitSmS1S2S2()
if self._deleted:
return True
self.setSmS1S2S2(__class__.SmS1S2S2.s4)
wasEventProcessed = True
return wasEventProcessed
def goToS7(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1S5S5 = self._smS1S5S5
if aSmS1S5S5 is __class__.SmS1S5S5.s6:
self.exitSmS1S5S5()
if self._deleted:
return True
self.setSmS1S5S5(__class__.SmS1S5S5.s7)
wasEventProcessed = True
return wasEventProcessed
def goToS10(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1S8S8 = self._smS1S8S8
if aSmS1S8S8 is __class__.SmS1S8S8.s9:
self.exitSmS1S8S8()
if self._deleted:
return True
self.setSmS1S8S8(__class__.SmS1S8S8.s10)
wasEventProcessed = True
return wasEventProcessed
def exitSm(self):
self._smVisit += 1
if self._sm is __class__.Sm.s1:
self.exitSmS1S2()
if self._deleted:
return
self.exitSmS1S5()
if self._deleted:
return
self.exitSmS1S8()
def setSm(self, aSm):
self._sm = aSm
self._smVisit += 1
visit = self._smVisit
if self._sm is __class__.Sm.s1:
if self._smS1S2 is __class__.SmS1S2.Null:
self.setSmS1S2(__class__.SmS1S2.s2)
if self._deleted or self._smVisit != visit:
return
if self._smS1S5 is __class__.SmS1S5.Null:
self.setSmS1S5(__class__.SmS1S5.s5)
if self._deleted or self._smVisit != visit:
return
if self._smS1S8 is __class__.SmS1S8.Null:
self.setSmS1S8(__class__.SmS1S8.s8)
def exitSmS1S2(self):
self._smS1S2Visit += 1
if self._smS1S2 is __class__.SmS1S2.s2:
self.exitSmS1S2S2()
if self._deleted:
return
self.setSmS1S2(__class__.SmS1S2.Null)
def setSmS1S2(self, aSmS1S2):
self._smS1S2 = aSmS1S2
self._smS1S2Visit += 1
visit = self._smS1S2Visit
if self._sm is not __class__.Sm.s1 and aSmS1S2 is not __class__.SmS1S2.Null:
self.setSm(__class__.Sm.s1)
if self._deleted or self._smS1S2Visit != visit:
return
if self._smS1S2 is __class__.SmS1S2.s2:
if self._smS1S2S2 is __class__.SmS1S2S2.Null:
self.setSmS1S2S2(__class__.SmS1S2S2.s3)
def exitSmS1S2S2(self):
self._smS1S2S2Visit += 1
if self._smS1S2S2 is __class__.SmS1S2S2.s3:
self.setSmS1S2S2(__class__.SmS1S2S2.Null)
elif self._smS1S2S2 is __class__.SmS1S2S2.s4:
self.setSmS1S2S2(__class__.SmS1S2S2.Null)
def setSmS1S2S2(self, aSmS1S2S2):
self._smS1S2S2 = aSmS1S2S2
self._smS1S2S2Visit += 1
visit = self._smS1S2S2Visit
if self._smS1S2 is not __class__.SmS1S2.s2 and aSmS1S2S2 is not __class__.SmS1S2S2.Null:
self.setSmS1S2(__class__.SmS1S2.s2)
if self._deleted or self._smS1S2S2Visit != visit:
return
if self._smS1S2S2 is __class__.SmS1S2S2.s4:
if self._smS1S5S5 is __class__.SmS1S5S5.s7 and self._smS1S8S8 is __class__.SmS1S8S8.s10:
self.delete()
def exitSmS1S5(self):
self._smS1S5Visit += 1
if self._smS1S5 is __class__.SmS1S5.s5:
self.exitSmS1S5S5()
if self._deleted:
return
self.setSmS1S5(__class__.SmS1S5.Null)
def setSmS1S5(self, aSmS1S5):
self._smS1S5 = aSmS1S5
self._smS1S5Visit += 1
visit = self._smS1S5Visit
if self._sm is not __class__.Sm.s1 and aSmS1S5 is not __class__.SmS1S5.Null:
self.setSm(__class__.Sm.s1)
if self._deleted or self._smS1S5Visit != visit:
return
if self._smS1S5 is __class__.SmS1S5.s5:
if self._smS1S5S5 is __class__.SmS1S5S5.Null:
self.setSmS1S5S5(__class__.SmS1S5S5.s6)
def exitSmS1S5S5(self):
self._smS1S5S5Visit += 1
if self._smS1S5S5 is __class__.SmS1S5S5.s6:
self.setSmS1S5S5(__class__.SmS1S5S5.Null)
elif self._smS1S5S5 is __class__.SmS1S5S5.s7:
self.setSmS1S5S5(__class__.SmS1S5S5.Null)
def setSmS1S5S5(self, aSmS1S5S5):
self._smS1S5S5 = aSmS1S5S5
self._smS1S5S5Visit += 1
visit = self._smS1S5S5Visit
if self._smS1S5 is not __class__.SmS1S5.s5 and aSmS1S5S5 is not __class__.SmS1S5S5.Null:
self.setSmS1S5(__class__.SmS1S5.s5)
if self._deleted or self._smS1S5S5Visit != visit:
return
if self._smS1S5S5 is __class__.SmS1S5S5.s7:
if self._smS1S2S2 is __class__.SmS1S2S2.s4 and self._smS1S8S8 is __class__.SmS1S8S8.s10:
self.delete()
def exitSmS1S8(self):
self._smS1S8Visit += 1
if self._smS1S8 is __class__.SmS1S8.s8:
self.exitSmS1S8S8()
if self._deleted:
return
self.setSmS1S8(__class__.SmS1S8.Null)
def setSmS1S8(self, aSmS1S8):
self._smS1S8 = aSmS1S8
self._smS1S8Visit += 1
visit = self._smS1S8Visit
if self._sm is not __class__.Sm.s1 and aSmS1S8 is not __class__.SmS1S8.Null:
self.setSm(__class__.Sm.s1)
if self._deleted or self._smS1S8Visit != visit:
return
if self._smS1S8 is __class__.SmS1S8.s8:
if self._smS1S8S8 is __class__.SmS1S8S8.Null:
self.setSmS1S8S8(__class__.SmS1S8S8.s9)
def exitSmS1S8S8(self):
self._smS1S8S8Visit += 1
if self._smS1S8S8 is __class__.SmS1S8S8.s9:
self.setSmS1S8S8(__class__.SmS1S8S8.Null)
elif self._smS1S8S8 is __class__.SmS1S8S8.s10:
self.setSmS1S8S8(__class__.SmS1S8S8.Null)
def setSmS1S8S8(self, aSmS1S8S8):
self._smS1S8S8 = aSmS1S8S8
self._smS1S8S8Visit += 1
visit = self._smS1S8S8Visit
if self._smS1S8 is not __class__.SmS1S8.s8 and aSmS1S8S8 is not __class__.SmS1S8S8.Null:
self.setSmS1S8(__class__.SmS1S8.s8)
if self._deleted or self._smS1S8S8Visit != visit:
return
if self._smS1S8S8 is __class__.SmS1S8S8.s10:
if self._smS1S2S2 is __class__.SmS1S2S2.s4 and self._smS1S5S5 is __class__.SmS1S5S5.s7:
self.delete()
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class X:
class Sm(Enum):
s1 = "s1"
Final = "Final"
s2 = "s2"
def __str__(self):
return self.value
class SmS1O1(Enum):
Null = "Null"
o1 = "o1"
def __str__(self):
return self.value
class SmS1O1O1(Enum):
Null = "Null"
o1Start = "o1Start"
o1Final = "o1Final"
def __str__(self):
return self.value
class SmS1O2(Enum):
Null = "Null"
o2 = "o2"
def __str__(self):
return self.value
class SmS1O2O2(Enum):
Null = "Null"
o2Start = "o2Start"
o2Final = "o2Final"
def __str__(self):
return self.value
class SmS2(Enum):
Null = "Null"
s2Start = "s2Start"
s2Final = "s2Final"
def __str__(self):
return self.value
def __init__(self):
self._sm = None
self._smVisit = 0
self._smS1O1 = None
self._smS1O1Visit = 0
self._smS1O1O1 = None
self._smS1O1O1Visit = 0
self._smS1O2 = None
self._smS1O2Visit = 0
self._smS1O2O2 = None
self._smS1O2O2Visit = 0
self._smS2 = None
self._smS2Visit = 0
self._deleted = False
self.setSmS1O1(__class__.SmS1O1.Null)
if self._deleted:
return
self.setSmS1O1O1(__class__.SmS1O1O1.Null)
if self._deleted:
return
self.setSmS1O2(__class__.SmS1O2.Null)
if self._deleted:
return
self.setSmS1O2O2(__class__.SmS1O2O2.Null)
if self._deleted:
return
self.setSmS2(__class__.SmS2.Null)
if self._deleted:
return
self.setSm(__class__.Sm.s1)
if self._deleted:
return
def getSmFullName(self):
answer = str(self._sm)
if self._smS1O1 is not __class__.SmS1O1.Null:
answer += "." + str(self._smS1O1)
if self._smS1O1O1 is not __class__.SmS1O1O1.Null:
answer += "." + str(self._smS1O1O1)
if self._smS1O2 is not __class__.SmS1O2.Null:
answer += "." + str(self._smS1O2)
if self._smS1O2O2 is not __class__.SmS1O2O2.Null:
answer += "." + str(self._smS1O2O2)
if self._smS2 is not __class__.SmS2.Null:
answer += "." + str(self._smS2)
return answer
def getSm(self):
return self._sm
def getSmS1O1(self):
return self._smS1O1
def getSmS1O1O1(self):
return self._smS1O1O1
def getSmS1O2(self):
return self._smS1O2
def getSmS1O2O2(self):
return self._smS1O2O2
def getSmS2(self):
return self._smS2
def goToS2(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1O1 = self._smS1O1
if aSmS1O1 is __class__.SmS1O1.o1:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def goBigFinal(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1O1O1 = self._smS1O1O1
if aSmS1O1O1 is __class__.SmS1O1O1.o1Start:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.Final)
wasEventProcessed = True
return wasEventProcessed
def completeO1(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1O1O1 = self._smS1O1O1
if aSmS1O1O1 is __class__.SmS1O1O1.o1Start:
self.exitSmS1O1O1()
if self._deleted:
return True
self.setSmS1O1O1(__class__.SmS1O1O1.o1Final)
wasEventProcessed = True
return wasEventProcessed
def completeO2(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1O2O2 = self._smS1O2O2
if aSmS1O2O2 is __class__.SmS1O2O2.o2Start:
self.exitSmS1O2O2()
if self._deleted:
return True
self.setSmS1O2O2(__class__.SmS1O2O2.o2Final)
wasEventProcessed = True
return wasEventProcessed
def completeS2(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS2 = self._smS2
if aSmS2 is __class__.SmS2.s2Start:
self.exitSmS2()
if self._deleted:
return True
self.setSmS2(__class__.SmS2.s2Final)
wasEventProcessed = True
return wasEventProcessed
def exitSm(self):
self._smVisit += 1
if self._sm is __class__.Sm.s1:
self.exitSmS1O1()
if self._deleted:
return
self.exitSmS1O2()
elif self._sm is __class__.Sm.s2:
self.exitSmS2()
def setSm(self, aSm):
self._sm = aSm
self._smVisit += 1
visit = self._smVisit
if self._sm is __class__.Sm.s1:
if self._smS1O1 is __class__.SmS1O1.Null:
self.setSmS1O1(__class__.SmS1O1.o1)
if self._deleted or self._smVisit != visit:
return
if self._smS1O2 is __class__.SmS1O2.Null:
self.setSmS1O2(__class__.SmS1O2.o2)
elif self._sm is __class__.Sm.Final:
self.delete()
elif self._sm is __class__.Sm.s2:
if self._smS2 is __class__.SmS2.Null:
self.setSmS2(__class__.SmS2.s2Start)
def exitSmS1O1(self):
self._smS1O1Visit += 1
if self._smS1O1 is __class__.SmS1O1.o1:
self.exitSmS1O1O1()
if self._deleted:
return
self.setSmS1O1(__class__.SmS1O1.Null)
def setSmS1O1(self, aSmS1O1):
self._smS1O1 = aSmS1O1
self._smS1O1Visit += 1
visit = self._smS1O1Visit
if self._sm is not __class__.Sm.s1 and aSmS1O1 is not __class__.SmS1O1.Null:
self.setSm(__class__.Sm.s1)
if self._deleted or self._smS1O1Visit != visit:
return
if self._smS1O1 is __class__.SmS1O1.o1:
if self._smS1O1O1 is __class__.SmS1O1O1.Null:
self.setSmS1O1O1(__class__.SmS1O1O1.o1Start)
def exitSmS1O1O1(self):
self._smS1O1O1Visit += 1
if self._smS1O1O1 is __class__.SmS1O1O1.o1Start:
self.setSmS1O1O1(__class__.SmS1O1O1.Null)
elif self._smS1O1O1 is __class__.SmS1O1O1.o1Final:
self.setSmS1O1O1(__class__.SmS1O1O1.Null)
def setSmS1O1O1(self, aSmS1O1O1):
self._smS1O1O1 = aSmS1O1O1
self._smS1O1O1Visit += 1
visit = self._smS1O1O1Visit
if self._smS1O1 is not __class__.SmS1O1.o1 and aSmS1O1O1 is not __class__.SmS1O1O1.Null:
self.setSmS1O1(__class__.SmS1O1.o1)
if self._deleted or self._smS1O1O1Visit != visit:
return
if self._smS1O1O1 is __class__.SmS1O1O1.o1Final:
if self._smS1O2O2 is __class__.SmS1O2O2.o2Final:
self.delete()
def exitSmS1O2(self):
self._smS1O2Visit += 1
if self._smS1O2 is __class__.SmS1O2.o2:
self.exitSmS1O2O2()
if self._deleted:
return
self.setSmS1O2(__class__.SmS1O2.Null)
def setSmS1O2(self, aSmS1O2):
self._smS1O2 = aSmS1O2
self._smS1O2Visit += 1
visit = self._smS1O2Visit
if self._sm is not __class__.Sm.s1 and aSmS1O2 is not __class__.SmS1O2.Null:
self.setSm(__class__.Sm.s1)
if self._deleted or self._smS1O2Visit != visit:
return
if self._smS1O2 is __class__.SmS1O2.o2:
if self._smS1O2O2 is __class__.SmS1O2O2.Null:
self.setSmS1O2O2(__class__.SmS1O2O2.o2Start)
def exitSmS1O2O2(self):
self._smS1O2O2Visit += 1
if self._smS1O2O2 is __class__.SmS1O2O2.o2Start:
self.setSmS1O2O2(__class__.SmS1O2O2.Null)
elif self._smS1O2O2 is __class__.SmS1O2O2.o2Final:
self.setSmS1O2O2(__class__.SmS1O2O2.Null)
def setSmS1O2O2(self, aSmS1O2O2):
self._smS1O2O2 = aSmS1O2O2
self._smS1O2O2Visit += 1
visit = self._smS1O2O2Visit
if self._smS1O2 is not __class__.SmS1O2.o2 and aSmS1O2O2 is not __class__.SmS1O2O2.Null:
self.setSmS1O2(__class__.SmS1O2.o2)
if self._deleted or self._smS1O2O2Visit != visit:
return
if self._smS1O2O2 is __class__.SmS1O2O2.o2Final:
if self._smS1O1O1 is __class__.SmS1O1O1.o1Final:
self.delete()
def exitSmS2(self):
self._smS2Visit += 1
if self._smS2 is __class__.SmS2.s2Start:
self.setSmS2(__class__.SmS2.Null)
elif self._smS2 is __class__.SmS2.s2Final:
self.setSmS2(__class__.SmS2.Null)
def setSmS2(self, aSmS2):
self._smS2 = aSmS2
self._smS2Visit += 1
visit = self._smS2Visit
if self._sm is not __class__.Sm.s2 and aSmS2 is not __class__.SmS2.Null:
self.setSm(__class__.Sm.s2)
if self._deleted or self._smS2Visit != visit:
return
if self._smS2 is __class__.SmS2.s2Final:
self.delete()
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class X:
class Sm(Enum):
o1 = "o1"
def __str__(self):
return self.value
class SmO1S1(Enum):
Null = "Null"
s1 = "s1"
def __str__(self):
return self.value
class SmO1S1S2(Enum):
Null = "Null"
s2 = "s2"
def __str__(self):
return self.value
class SmO1S1S2S2(Enum):
Null = "Null"
s3 = "s3"
s4 = "s4"
def __str__(self):
return self.value
class SmO1S1S5(Enum):
Null = "Null"
s5 = "s5"
def __str__(self):
return self.value
class SmO1S1S5S5(Enum):
Null = "Null"
s6 = "s6"
def __str__(self):
return self.value
class SmO1S7(Enum):
Null = "Null"
s7 = "s7"
def __str__(self):
return self.value
class SmO1S7S7(Enum):
Null = "Null"
s8 = "s8"
s9 = "s9"
def __str__(self):
return self.value
def __init__(self):
self._sm = None
self._smVisit = 0
self._smO1S1 = None
self._smO1S1Visit = 0
self._smO1S1S2 = None
self._smO1S1S2Visit = 0
self._smO1S1S2S2 = None
self._smO1S1S2S2Visit = 0
self._smO1S1S5 = None
self._smO1S1S5Visit = 0
self._smO1S1S5S5 = None
self._smO1S1S5S5Visit = 0
self._smO1S7 = None
self._smO1S7Visit = 0
self._smO1S7S7 = None
self._smO1S7S7Visit = 0
self._deleted = False
self.setSmO1S1(__class__.SmO1S1.Null)
if self._deleted:
return
self.setSmO1S1S2(__class__.SmO1S1S2.Null)
if self._deleted:
return
self.setSmO1S1S2S2(__class__.SmO1S1S2S2.Null)
if self._deleted:
return
self.setSmO1S1S5(__class__.SmO1S1S5.Null)
if self._deleted:
return
self.setSmO1S1S5S5(__class__.SmO1S1S5S5.Null)
if self._deleted:
return
self.setSmO1S7(__class__.SmO1S7.Null)
if self._deleted:
return
self.setSmO1S7S7(__class__.SmO1S7S7.Null)
if self._deleted:
return
self.setSm(__class__.Sm.o1)
if self._deleted:
return
def getSmFullName(self):
answer = str(self._sm)
if self._smO1S1 is not __class__.SmO1S1.Null:
answer += "." + str(self._smO1S1)
if self._smO1S1S2 is not __class__.SmO1S1S2.Null:
answer += "." + str(self._smO1S1S2)
if self._smO1S1S2S2 is not __class__.SmO1S1S2S2.Null:
answer += "." + str(self._smO1S1S2S2)
if self._smO1S1S5 is not __class__.SmO1S1S5.Null:
answer += "." + str(self._smO1S1S5)
if self._smO1S1S5S5 is not __class__.SmO1S1S5S5.Null:
answer += "." + str(self._smO1S1S5S5)
if self._smO1S7 is not __class__.SmO1S7.Null:
answer += "." + str(self._smO1S7)
if self._smO1S7S7 is not __class__.SmO1S7S7.Null:
answer += "." + str(self._smO1S7S7)
return answer
def getSm(self):
return self._sm
def getSmO1S1(self):
return self._smO1S1
def getSmO1S1S2(self):
return self._smO1S1S2
def getSmO1S1S2S2(self):
return self._smO1S1S2S2
def getSmO1S1S5(self):
return self._smO1S1S5
def getSmO1S1S5S5(self):
return self._smO1S1S5S5
def getSmO1S7(self):
return self._smO1S7
def getSmO1S7S7(self):
return self._smO1S7S7
def goToS4Final(self):
if self._deleted:
return False
wasEventProcessed = False
aSmO1S1S2S2 = self._smO1S1S2S2
if aSmO1S1S2S2 is __class__.SmO1S1S2S2.s3:
self.exitSmO1S1S2S2()
if self._deleted:
return True
self.setSmO1S1S2S2(__class__.SmO1S1S2S2.s4)
wasEventProcessed = True
return wasEventProcessed
def goToS9Final(self):
if self._deleted:
return False
wasEventProcessed = False
aSmO1S7S7 = self._smO1S7S7
if aSmO1S7S7 is __class__.SmO1S7S7.s8:
self.exitSmO1S7S7()
if self._deleted:
return True
self.setSmO1S7S7(__class__.SmO1S7S7.s9)
wasEventProcessed = True
return wasEventProcessed
def exitSm(self):
self._smVisit += 1
if self._sm is __class__.Sm.o1:
self.exitSmO1S1()
if self._deleted:
return
self.exitSmO1S7()
def setSm(self, aSm):
self._sm = aSm
self._smVisit += 1
visit = self._smVisit
if self._sm is __class__.Sm.o1:
if self._smO1S1 is __class__.SmO1S1.Null:
self.setSmO1S1(__class__.SmO1S1.s1)
if self._deleted or self._smVisit != visit:
return
if self._smO1S7 is __class__.SmO1S7.Null:
self.setSmO1S7(__class__.SmO1S7.s7)
def exitSmO1S1(self):
self._smO1S1Visit += 1
if self._smO1S1 is __class__.SmO1S1.s1:
self.exitSmO1S1S2()
if self._deleted:
return
self.exitSmO1S1S5()
if self._deleted:
return
self.setSmO1S1(__class__.SmO1S1.Null)
def setSmO1S1(self, aSmO1S1):
self._smO1S1 = aSmO1S1
self._smO1S1Visit += 1
visit = self._smO1S1Visit
if self._sm is not __class__.Sm.o1 and aSmO1S1 is not __class__.SmO1S1.Null:
self.setSm(__class__.Sm.o1)
if self._deleted or self._smO1S1Visit != visit:
return
if self._smO1S1 is __class__.SmO1S1.s1:
if self._smO1S1S2 is __class__.SmO1S1S2.Null:
self.setSmO1S1S2(__class__.SmO1S1S2.s2)
if self._deleted or self._smO1S1Visit != visit:
return
if self._smO1S1S5 is __class__.SmO1S1S5.Null:
self.setSmO1S1S5(__class__.SmO1S1S5.s5)
def exitSmO1S1S2(self):
self._smO1S1S2Visit += 1
if self._smO1S1S2 is __class__.SmO1S1S2.s2:
self.exitSmO1S1S2S2()
if self._deleted:
return
self.setSmO1S1S2(__class__.SmO1S1S2.Null)
def setSmO1S1S2(self, aSmO1S1S2):
self._smO1S1S2 = aSmO1S1S2
self._smO1S1S2Visit += 1
visit = self._smO1S1S2Visit
if self._smO1S1 is not __class__.SmO1S1.s1 and aSmO1S1S2 is not __class__.SmO1S1S2.Null:
self.setSmO1S1(__class__.SmO1S1.s1)
if self._deleted or self._smO1S1S2Visit != visit:
return
if self._smO1S1S2 is __class__.SmO1S1S2.s2:
if self._smO1S1S2S2 is __class__.SmO1S1S2S2.Null:
self.setSmO1S1S2S2(__class__.SmO1S1S2S2.s3)
def exitSmO1S1S2S2(self):
self._smO1S1S2S2Visit += 1
if self._smO1S1S2S2 is __class__.SmO1S1S2S2.s3:
self.setSmO1S1S2S2(__class__.SmO1S1S2S2.Null)
elif self._smO1S1S2S2 is __class__.SmO1S1S2S2.s4:
self.setSmO1S1S2S2(__class__.SmO1S1S2S2.Null)
def setSmO1S1S2S2(self, aSmO1S1S2S2):
self._smO1S1S2S2 = aSmO1S1S2S2
self._smO1S1S2S2Visit += 1
visit = self._smO1S1S2S2Visit
if self._smO1S1S2 is not __class__.SmO1S1S2.s2 and aSmO1S1S2S2 is not __class__.SmO1S1S2S2.Null:
self.setSmO1S1S2(__class__.SmO1S1S2.s2)
if self._deleted or self._smO1S1S2S2Visit != visit:
return
if self._smO1S1S2S2 is __class__.SmO1S1S2S2.s4:
if self._smO1S1S5S5 is __class__.SmO1S1S5S5.s6 and self._smO1S7S7 is __class__.SmO1S7S7.s9:
self.delete()
def exitSmO1S1S5(self):
self._smO1S1S5Visit += 1
if self._smO1S1S5 is __class__.SmO1S1S5.s5:
self.exitSmO1S1S5S5()
if self._deleted:
return
self.setSmO1S1S5(__class__.SmO1S1S5.Null)
def setSmO1S1S5(self, aSmO1S1S5):
self._smO1S1S5 = aSmO1S1S5
self._smO1S1S5Visit += 1
visit = self._smO1S1S5Visit
if self._smO1S1 is not __class__.SmO1S1.s1 and aSmO1S1S5 is not __class__.SmO1S1S5.Null:
self.setSmO1S1(__class__.SmO1S1.s1)
if self._deleted or self._smO1S1S5Visit != visit:
return
if self._smO1S1S5 is __class__.SmO1S1S5.s5:
if self._smO1S1S5S5 is __class__.SmO1S1S5S5.Null:
self.setSmO1S1S5S5(__class__.SmO1S1S5S5.s6)
def exitSmO1S1S5S5(self):
self._smO1S1S5S5Visit += 1
if self._smO1S1S5S5 is __class__.SmO1S1S5S5.s6:
self.setSmO1S1S5S5(__class__.SmO1S1S5S5.Null)
def setSmO1S1S5S5(self, aSmO1S1S5S5):
self._smO1S1S5S5 = aSmO1S1S5S5
self._smO1S1S5S5Visit += 1
visit = self._smO1S1S5S5Visit
if self._smO1S1S5 is not __class__.SmO1S1S5.s5 and aSmO1S1S5S5 is not __class__.SmO1S1S5S5.Null:
self.setSmO1S1S5(__class__.SmO1S1S5.s5)
if self._deleted or self._smO1S1S5S5Visit != visit:
return
if self._smO1S1S5S5 is __class__.SmO1S1S5S5.s6:
if self._smO1S1S2S2 is __class__.SmO1S1S2S2.s4 and self._smO1S7S7 is __class__.SmO1S7S7.s9:
self.delete()
def exitSmO1S7(self):
self._smO1S7Visit += 1
if self._smO1S7 is __class__.SmO1S7.s7:
self.exitSmO1S7S7()
if self._deleted:
return
self.setSmO1S7(__class__.SmO1S7.Null)
def setSmO1S7(self, aSmO1S7):
self._smO1S7 = aSmO1S7
self._smO1S7Visit += 1
visit = self._smO1S7Visit
if self._sm is not __class__.Sm.o1 and aSmO1S7 is not __class__.SmO1S7.Null:
self.setSm(__class__.Sm.o1)
if self._deleted or self._smO1S7Visit != visit:
return
if self._smO1S7 is __class__.SmO1S7.s7:
if self._smO1S7S7 is __class__.SmO1S7S7.Null:
self.setSmO1S7S7(__class__.SmO1S7S7.s8)
def exitSmO1S7S7(self):
self._smO1S7S7Visit += 1
if self._smO1S7S7 is __class__.SmO1S7S7.s8:
self.setSmO1S7S7(__class__.SmO1S7S7.Null)
elif self._smO1S7S7 is __class__.SmO1S7S7.s9:
self.setSmO1S7S7(__class__.SmO1S7S7.Null)
def setSmO1S7S7(self, aSmO1S7S7):
self._smO1S7S7 = aSmO1S7S7
self._smO1S7S7Visit += 1
visit = self._smO1S7S7Visit
if self._smO1S7 is not __class__.SmO1S7.s7 and aSmO1S7S7 is not __class__.SmO1S7S7.Null:
self.setSmO1S7(__class__.SmO1S7.s7)
if self._deleted or self._smO1S7S7Visit != visit:
return
if self._smO1S7S7 is __class__.SmO1S7S7.s9:
if self._smO1S1S2S2 is __class__.SmO1S1S2S2.s4 and self._smO1S1S5S5 is __class__.SmO1S1S5S5.s6:
self.delete()
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class X:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
s3 = "s3"
def __str__(self):
return self.value
def __init__(self):
self._sm = None
self._deleted = False
self.setSm(__class__.Sm.s1)
def getSmFullName(self):
answer = str(self._sm)
return answer
def getSm(self):
return self._sm
def goToS2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def goToS3(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self.setSm(__class__.Sm.s3)
wasEventProcessed = True
return wasEventProcessed
def setSm(self, aSm):
self._sm = aSm
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class Mentor:
class Status(Enum):
Ok = "Ok"
NotOk = "NotOk"
def __str__(self):
return self.value
class TimedEventHandler:
def __init__(self, controller, timeoutMethodName, howLongInSeconds):
self._controller = controller
self._timeoutMethodName = timeoutMethodName
self._timer = threading.Timer(howLongInSeconds, self.run)
self._timer.daemon = False
def start(self):
self._timer.start()
def stop(self):
self._timer.cancel()
def isCurrent(self, handler, state, armedState):
return not self._timer.finished.is_set() and not self._controller._deleted and handler is self and state is armedState
def run(self):
controller = self._controller
if self._timeoutMethodName == "timeoutOkToNotOk":
if self.isCurrent(controller._timeoutOkToNotOkHandler, controller._status, Mentor.Status.Ok):
if not controller.timeoutOkToNotOk() and self.isCurrent(controller._timeoutOkToNotOkHandler, controller._status, Mentor.Status.Ok):
controller.startTimeoutOkToNotOkHandler()
elif self._timeoutMethodName == "timeoutNotOkToOk":
if self.isCurrent(controller._timeoutNotOkToOkHandler, controller._status, Mentor.Status.NotOk):
if not controller.timeoutNotOkToOk() and self.isCurrent(controller._timeoutNotOkToOkHandler, controller._status, Mentor.Status.NotOk):
controller.startTimeoutNotOkToOkHandler()
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __canProcess(self, call):
name = call.__name__
return (self._status is __class__.Status.Ok and name in ("_timeoutOkToNotOk",)
or self._status is __class__.Status.NotOk and name in ("_timeoutNotOkToOk",))
def __init__(self):
self._howLongUntilOk = 3
self.__eventQueue = __class__.MessageQueue(self.__canProcess)
self._status = None
self._statusVisit = 0
self._timeoutOkToNotOkHandler = None
self._timeoutNotOkToOkHandler = None
self._deleted = False
self.setStatus(__class__.Status.Ok)
if self._deleted:
return
self.__eventQueue.start()
def setHowLongUntilOk(self, aHowLongUntilOk):
self._howLongUntilOk = aHowLongUntilOk
return True
def getHowLongUntilOk(self):
return self._howLongUntilOk
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def _timeoutOkToNotOk(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Ok:
self.exitStatus()
if self._deleted:
return True
self.setStatus(__class__.Status.NotOk)
wasEventProcessed = True
return wasEventProcessed
def timeoutOkToNotOk(self):
self.__eventQueue.put(self._timeoutOkToNotOk)
return True
def _timeoutNotOkToOk(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.NotOk:
self.exitStatus()
if self._deleted:
return True
self.setStatus(__class__.Status.Ok)
wasEventProcessed = True
return wasEventProcessed
def timeoutNotOkToOk(self):
self.__eventQueue.put(self._timeoutNotOkToOk)
return True
def exitStatus(self):
self._statusVisit += 1
if self._status is __class__.Status.Ok:
self.stopTimeoutOkToNotOkHandler()
elif self._status is __class__.Status.NotOk:
self.stopTimeoutNotOkToOkHandler()
def setStatus(self, aStatus):
self._status = aStatus
self._statusVisit += 1
if self._status is __class__.Status.Ok:
self.startTimeoutOkToNotOkHandler()
elif self._status is __class__.Status.NotOk:
self.startTimeoutNotOkToOkHandler()
def startTimeoutOkToNotOkHandler(self):
if self._deleted:
return
if self._timeoutOkToNotOkHandler is not None:
self._timeoutOkToNotOkHandler.stop()
visit = self._statusVisit
delay = 4
if self._deleted or self._statusVisit != visit:
return
self._timeoutOkToNotOkHandler = __class__.TimedEventHandler(self, "timeoutOkToNotOk", delay)
self._timeoutOkToNotOkHandler.start()
def stopTimeoutOkToNotOkHandler(self):
if self._timeoutOkToNotOkHandler is not None:
self._timeoutOkToNotOkHandler.stop()
def startTimeoutNotOkToOkHandler(self):
if self._deleted:
return
if self._timeoutNotOkToOkHandler is not None:
self._timeoutNotOkToOkHandler.stop()
visit = self._statusVisit
delay = self._howLongUntilOk
if self._deleted or self._statusVisit != visit:
return
self._timeoutNotOkToOkHandler = __class__.TimedEventHandler(self, "timeoutNotOkToOk", delay)
self._timeoutNotOkToOkHandler.start()
def stopTimeoutNotOkToOkHandler(self):
if self._timeoutNotOkToOkHandler is not None:
self._timeoutNotOkToOkHandler.stop()
def delete(self):
self._deleted = True
self.stopTimeoutOkToNotOkHandler()
self.stopTimeoutNotOkToOkHandler()
self.__eventQueue.stop()
def __str__(self):
return (super().__str__() + "["
+ "howLongUntilOk:" + str(self.getHowLongUntilOk())
+ "]")
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class stateMachineWithNegativeNumberGuard2:
class Status(Enum):
on = "on"
off = "off"
def __str__(self):
return self.value
def __init__(self):
self._status = None
self._deleted = False
self.setStatus(__class__.Status.on)
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def turnOff(self, pn):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.on:
if pn < -1:
self.setStatus(__class__.Status.off)
wasEventProcessed = True
return wasEventProcessed
def turnOn(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.off:
self.setStatus(__class__.Status.on)
wasEventProcessed = True
return wasEventProcessed
def setStatus(self, aStatus):
self._status = aStatus
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class X:
class Sm(Enum):
s0 = "s0"
s1 = "s1"
def __str__(self):
return self.value
class SmS0T1(Enum):
Null = "Null"
t1 = "t1"
def __str__(self):
return self.value
class SmS0T2(Enum):
Null = "Null"
t2 = "t2"
t3 = "t3"
def __str__(self):
return self.value
class SmS1(Enum):
Null = "Null"
s2 = "s2"
def __str__(self):
return self.value
class SmS1S2T4(Enum):
Null = "Null"
t4 = "t4"
t5 = "t5"
def __str__(self):
return self.value
class SmS1S2T6(Enum):
Null = "Null"
t6 = "t6"
t7 = "t7"
def __str__(self):
return self.value
def __init__(self):
self._sm = None
self._smVisit = 0
self._smS0T1 = None
self._smS0T2 = None
self._smS1 = None
self._smS1Visit = 0
self._smS1S2T4 = None
self._smS1S2T6 = None
self._deleted = False
self.setSmS0T1(__class__.SmS0T1.Null)
self.setSmS0T2(__class__.SmS0T2.Null)
self.setSmS1(__class__.SmS1.Null)
self.setSmS1S2T4(__class__.SmS1S2T4.Null)
self.setSmS1S2T6(__class__.SmS1S2T6.Null)
self.setSm(__class__.Sm.s0)
def getSmFullName(self):
answer = str(self._sm)
if self._smS0T1 is not __class__.SmS0T1.Null:
answer += "." + str(self._smS0T1)
if self._smS0T2 is not __class__.SmS0T2.Null:
answer += "." + str(self._smS0T2)
if self._smS1 is not __class__.SmS1.Null:
answer += "." + str(self._smS1)
if self._smS1S2T4 is not __class__.SmS1S2T4.Null:
answer += "." + str(self._smS1S2T4)
if self._smS1S2T6 is not __class__.SmS1S2T6.Null:
answer += "." + str(self._smS1S2T6)
return answer
def getSm(self):
return self._sm
def getSmS0T1(self):
return self._smS0T1
def getSmS0T2(self):
return self._smS0T2
def getSmS1(self):
return self._smS1
def getSmS1S2T4(self):
return self._smS1S2T4
def getSmS1S2T6(self):
return self._smS1S2T6
def goS1(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS0T1 = self._smS0T1
if aSmS0T1 is __class__.SmS0T1.t1:
self.exitSm()
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def goT3(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS0T2 = self._smS0T2
if aSmS0T2 is __class__.SmS0T2.t2:
self.exitSmS0T2()
self.setSmS0T2(__class__.SmS0T2.t3)
wasEventProcessed = True
return wasEventProcessed
def goT5(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1S2T4 = self._smS1S2T4
if aSmS1S2T4 is __class__.SmS1S2T4.t4:
self.exitSmS1S2T4()
self.setSmS1S2T4(__class__.SmS1S2T4.t5)
wasEventProcessed = True
return wasEventProcessed
def goT7(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1S2T6 = self._smS1S2T6
if aSmS1S2T6 is __class__.SmS1S2T6.t6:
self.exitSmS1S2T6()
self.setSmS1S2T6(__class__.SmS1S2T6.t7)
wasEventProcessed = True
return wasEventProcessed
def exitSm(self):
self._smVisit += 1
if self._sm is __class__.Sm.s0:
self.exitSmS0T1()
self.exitSmS0T2()
elif self._sm is __class__.Sm.s1:
self.exitSmS1()
def setSm(self, aSm):
self._sm = aSm
self._smVisit += 1
visit = self._smVisit
if self._sm is __class__.Sm.s0:
if self._smS0T1 is __class__.SmS0T1.Null:
self.setSmS0T1(__class__.SmS0T1.t1)
if self._smVisit != visit:
return
if self._smS0T2 is __class__.SmS0T2.Null:
self.setSmS0T2(__class__.SmS0T2.t2)
elif self._sm is __class__.Sm.s1:
if self._smS1 is __class__.SmS1.Null:
self.setSmS1(__class__.SmS1.s2)
def exitSmS0T1(self):
if self._smS0T1 is __class__.SmS0T1.t1:
self.setSmS0T1(__class__.SmS0T1.Null)
def setSmS0T1(self, aSmS0T1):
self._smS0T1 = aSmS0T1
if self._sm is not __class__.Sm.s0 and aSmS0T1 is not __class__.SmS0T1.Null:
self.setSm(__class__.Sm.s0)
def exitSmS0T2(self):
if self._smS0T2 is __class__.SmS0T2.t2:
self.setSmS0T2(__class__.SmS0T2.Null)
elif self._smS0T2 is __class__.SmS0T2.t3:
self.setSmS0T2(__class__.SmS0T2.Null)
def setSmS0T2(self, aSmS0T2):
self._smS0T2 = aSmS0T2
if self._sm is not __class__.Sm.s0 and aSmS0T2 is not __class__.SmS0T2.Null:
self.setSm(__class__.Sm.s0)
def exitSmS1(self):
self._smS1Visit += 1
if self._smS1 is __class__.SmS1.s2:
self.exitSmS1S2T4()
self.exitSmS1S2T6()
self.setSmS1(__class__.SmS1.Null)
def setSmS1(self, aSmS1):
self._smS1 = aSmS1
self._smS1Visit += 1
visit = self._smS1Visit
if self._sm is not __class__.Sm.s1 and aSmS1 is not __class__.SmS1.Null:
self.setSm(__class__.Sm.s1)
if self._smS1Visit != visit:
return
if self._smS1 is __class__.SmS1.s2:
if self._smS1S2T4 is __class__.SmS1S2T4.Null:
self.setSmS1S2T4(__class__.SmS1S2T4.t4)
if self._smS1Visit != visit:
return
if self._smS1S2T6 is __class__.SmS1S2T6.Null:
self.setSmS1S2T6(__class__.SmS1S2T6.t6)
def exitSmS1S2T4(self):
if self._smS1S2T4 is __class__.SmS1S2T4.t4:
self.setSmS1S2T4(__class__.SmS1S2T4.Null)
elif self._smS1S2T4 is __class__.SmS1S2T4.t5:
self.setSmS1S2T4(__class__.SmS1S2T4.Null)
def setSmS1S2T4(self, aSmS1S2T4):
self._smS1S2T4 = aSmS1S2T4
if self._smS1 is not __class__.SmS1.s2 and aSmS1S2T4 is not __class__.SmS1S2T4.Null:
self.setSmS1(__class__.SmS1.s2)
def exitSmS1S2T6(self):
if self._smS1S2T6 is __class__.SmS1S2T6.t6:
self.setSmS1S2T6(__class__.SmS1S2T6.Null)
elif self._smS1S2T6 is __class__.SmS1S2T6.t7:
self.setSmS1S2T6(__class__.SmS1S2T6.Null)
def setSmS1S2T6(self, aSmS1S2T6):
self._smS1S2T6 = aSmS1S2T6
if self._smS1 is not __class__.SmS1.s2 and aSmS1S2T6 is not __class__.SmS1S2T6.Null:
self.setSmS1(__class__.SmS1.s2)
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class X:
class Sm(Enum):
s1 = "s1"
Final = "Final"
def __str__(self):
return self.value
class SmS1(Enum):
Null = "Null"
s2 = "s2"
def __str__(self):
return self.value
def __init__(self):
self._sm = None
self._smS1 = None
self._deleted = False
self.setSmS1(__class__.SmS1.Null)
if self._deleted:
return
self.setSm(__class__.Sm.s1)
if self._deleted:
return
def getSmFullName(self):
answer = str(self._sm)
if self._smS1 is not __class__.SmS1.Null:
answer += "." + str(self._smS1)
return answer
def getSm(self):
return self._sm
def getSmS1(self):
return self._smS1
def goToFinal(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s2:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.Final)
wasEventProcessed = True
return wasEventProcessed
def exitSm(self):
if self._sm is __class__.Sm.s1:
self.exitSmS1()
def setSm(self, aSm):
self._sm = aSm
if self._sm is __class__.Sm.s1:
if self._smS1 is __class__.SmS1.Null:
self.setSmS1(__class__.SmS1.s2)
elif self._sm is __class__.Sm.Final:
self.delete()
def exitSmS1(self):
if self._smS1 is __class__.SmS1.s2:
self.setSmS1(__class__.SmS1.Null)
def setSmS1(self, aSmS1):
self._smS1 = aSmS1
if self._sm is not __class__.Sm.s1 and aSmS1 is not __class__.SmS1.Null:
self.setSm(__class__.Sm.s1)
if self._deleted:
return
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Course:
class Status(Enum):
Open = "Open"
def __str__(self):
return self.value
def __init__(self):
self._status = None
self._deleted = False
self.setStatus(__class__.Status.Open)
if self._deleted:
return
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def register(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Open:
print("transition")
if self._deleted:
return True
self.setStatus(__class__.Status.Open)
wasEventProcessed = True
return wasEventProcessed
def setStatus(self, aStatus):
self._status = aStatus
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class X:
class Sm(Enum):
s1 = "s1"
Final = "Final"
s3 = "s3"
def __str__(self):
return self.value
class SmS1(Enum):
Null = "Null"
s2 = "s2"
def __str__(self):
return self.value
class SmS3(Enum):
Null = "Null"
s4 = "s4"
def __str__(self):
return self.value
class SmS3S4(Enum):
Null = "Null"
s5 = "s5"
def __str__(self):
return self.value
def __init__(self):
self._sm = None
self._smS1 = None
self._smS3 = None
self._smS3Visit = 0
self._smS3S4 = None
self._deleted = False
self.setSmS1(__class__.SmS1.Null)
if self._deleted:
return
self.setSmS3(__class__.SmS3.Null)
if self._deleted:
return
self.setSmS3S4(__class__.SmS3S4.Null)
if self._deleted:
return
self.setSm(__class__.Sm.s1)
if self._deleted:
return
def getSmFullName(self):
answer = str(self._sm)
if self._smS1 is not __class__.SmS1.Null:
answer += "." + str(self._smS1)
if self._smS3 is not __class__.SmS3.Null:
answer += "." + str(self._smS3)
if self._smS3S4 is not __class__.SmS3S4.Null:
answer += "." + str(self._smS3S4)
return answer
def getSm(self):
return self._sm
def getSmS1(self):
return self._smS1
def getSmS3(self):
return self._smS3
def getSmS3S4(self):
return self._smS3S4
def goToS3(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.s3)
wasEventProcessed = True
return wasEventProcessed
def goToFinal(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
aSmS3S4 = self._smS3S4
if aSmS1 is __class__.SmS1.s2:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.Final)
wasEventProcessed = True
if self._deleted:
return True
if aSmS3S4 is __class__.SmS3S4.s5:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.Final)
wasEventProcessed = True
return wasEventProcessed
def exitSm(self):
if self._sm is __class__.Sm.s1:
self.exitSmS1()
elif self._sm is __class__.Sm.s3:
self.exitSmS3()
def setSm(self, aSm):
self._sm = aSm
if self._sm is __class__.Sm.s1:
if self._smS1 is __class__.SmS1.Null:
self.setSmS1(__class__.SmS1.s2)
elif self._sm is __class__.Sm.Final:
self.delete()
elif self._sm is __class__.Sm.s3:
if self._smS3 is __class__.SmS3.Null:
self.setSmS3(__class__.SmS3.s4)
def exitSmS1(self):
if self._smS1 is __class__.SmS1.s2:
self.setSmS1(__class__.SmS1.Null)
def setSmS1(self, aSmS1):
self._smS1 = aSmS1
if self._sm is not __class__.Sm.s1 and aSmS1 is not __class__.SmS1.Null:
self.setSm(__class__.Sm.s1)
if self._deleted:
return
def exitSmS3(self):
self._smS3Visit += 1
if self._smS3 is __class__.SmS3.s4:
self.exitSmS3S4()
if self._deleted:
return
self.setSmS3(__class__.SmS3.Null)
def setSmS3(self, aSmS3):
self._smS3 = aSmS3
self._smS3Visit += 1
visit = self._smS3Visit
if self._sm is not __class__.Sm.s3 and aSmS3 is not __class__.SmS3.Null:
self.setSm(__class__.Sm.s3)
if self._deleted or self._smS3Visit != visit:
return
if self._smS3 is __class__.SmS3.s4:
if self._smS3S4 is __class__.SmS3S4.Null:
self.setSmS3S4(__class__.SmS3S4.s5)
def exitSmS3S4(self):
if self._smS3S4 is __class__.SmS3S4.s5:
self.setSmS3S4(__class__.SmS3S4.Null)
def setSmS3S4(self, aSmS3S4):
self._smS3S4 = aSmS3S4
if self._smS3 is not __class__.SmS3.s4 and aSmS3S4 is not __class__.SmS3S4.Null:
self.setSmS3(__class__.SmS3.s4)
if self._deleted:
return
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Mentor:
class Status(Enum):
Ok = "Ok"
Final = "Final"
def __str__(self):
return self.value
def __init__(self):
self._status = None
self._deleted = False
self.setStatus(__class__.Status.Ok)
if self._deleted:
return
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def flip(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Ok:
self.setStatus(__class__.Status.Final)
wasEventProcessed = True
return wasEventProcessed
def setStatus(self, aStatus):
self._status = aStatus
if self._status is __class__.Status.Final:
self.delete()
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Course:
class Status(Enum):
Open = "Open"
def __str__(self):
return self.value
def __init__(self):
self._status = None
self._deleted = False
self.setStatus(__class__.Status.Open)
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def register(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Open:
self.setStatus(__class__.Status.Open)
wasEventProcessed = True
return wasEventProcessed
def setStatus(self, aStatus):
self._status = aStatus
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Course:
class Status(Enum):
Open = "Open"
Full = "Full"
error1 = "error1"
def __str__(self):
return self.value
def __init__(self):
self._status = None
self._deleted = False
self.setStatus(__class__.Status.Open)
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def register(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Open:
self.setStatus(__class__.Status.Full)
wasEventProcessed = True
else:
wasEventProcessed = self.unspecified(self.getStatus().value, "register") or wasEventProcessed
return wasEventProcessed
def unspecified(self, state, event):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Open:
self.setStatus(__class__.Status.error1)
wasEventProcessed = True
return wasEventProcessed
def reject(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Full:
self.setStatus(__class__.Status.Full)
wasEventProcessed = True
return wasEventProcessed
def __autotransition1__(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.error1:
self.setStatus(__class__.Status.Open)
wasEventProcessed = True
return wasEventProcessed
def setStatus(self, aStatus):
self._status = aStatus
if self._status is __class__.Status.error1:
self.__autotransition1__()
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Light:
class Status(Enum):
On = "On"
Off = "Off"
def __str__(self):
return self.value
def __init__(self):
self._status = None
self._statusVisit = 0
self._deleted = False
self.setStatus(__class__.Status.On)
if self._deleted:
return
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def flip(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.On:
self.setStatus(__class__.Status.Off)
wasEventProcessed = True
elif aStatus is __class__.Status.Off:
self.setStatus(__class__.Status.On)
wasEventProcessed = True
return wasEventProcessed
def setStatus(self, aStatus):
self._status = aStatus
self._statusVisit += 1
visit = self._statusVisit
if self._status is __class__.Status.On:
print("entry")
if self._deleted or self._statusVisit != visit:
return
print("entry2")
if self._deleted:
return
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from ThingInWorld import ThingInWorld
from enum import Enum
class Animal(ThingInWorld):
class State(Enum):
alive = "alive"
dead = "dead"
def __str__(self):
return self.value
class StateAlive(Enum):
Null = "Null"
normal = "normal"
zombie = "zombie"
def __str__(self):
return self.value
class StateAliveNormal(Enum):
Null = "Null"
baby = "baby"
adult = "adult"
def __str__(self):
return self.value
def __init__(self, aIsAlive, aWorld):
self._isAlive = aIsAlive
self._drops = []
self._world = None
self._state = None
self._stateAlive = None
self._stateAliveVisit = 0
self._stateAliveNormal = None
self._deleted = False
super().__init__()
if not self.setWorld(aWorld):
raise RuntimeError("Unable to create animal due to world. See https://manual.umple.org?RE002ViolationofAssociationMultiplicity.html")
self.setStateAlive(__class__.StateAlive.Null)
self.setStateAliveNormal(__class__.StateAliveNormal.Null)
self.setState(__class__.State.alive)
def setIsAlive(self, aIsAlive):
self._isAlive = aIsAlive
return True
def getIsAlive(self):
return self._isAlive
def isIsAlive(self):
return self._isAlive
def getStateFullName(self):
answer = str(self._state)
if self._stateAlive is not __class__.StateAlive.Null:
answer += "." + str(self._stateAlive)
if self._stateAliveNormal is not __class__.StateAliveNormal.Null:
answer += "." + str(self._stateAliveNormal)
return answer
def getState(self):
return self._state
def getStateAlive(self):
return self._stateAlive
def getStateAliveNormal(self):
return self._stateAliveNormal
def kill(self):
if self._deleted:
return False
wasEventProcessed = False
aState = self._state
if aState is __class__.State.alive:
self.exitState()
self.setState(__class__.State.dead)
wasEventProcessed = True
return wasEventProcessed
def haveBaby(self):
if self._deleted:
return False
wasEventProcessed = False
aStateAlive = self._stateAlive
if aStateAlive is __class__.StateAlive.zombie:
self.exitStateAlive()
self.setStateAliveNormal(__class__.StateAliveNormal.adult)
wasEventProcessed = True
return wasEventProcessed
def growUp(self):
if self._deleted:
return False
wasEventProcessed = False
aStateAliveNormal = self._stateAliveNormal
if aStateAliveNormal is __class__.StateAliveNormal.baby:
self.exitStateAliveNormal()
self.setStateAliveNormal(__class__.StateAliveNormal.adult)
wasEventProcessed = True
return wasEventProcessed
def zombify(self):
if self._deleted:
return False
wasEventProcessed = False
aStateAliveNormal = self._stateAliveNormal
if aStateAliveNormal is __class__.StateAliveNormal.adult:
self.exitStateAlive()
self.setStateAlive(__class__.StateAlive.zombie)
wasEventProcessed = True
return wasEventProcessed
def exitState(self):
if self._state is __class__.State.alive:
self.exitStateAlive()
def setState(self, aState):
self._state = aState
if self._state is __class__.State.alive:
if self._stateAlive is __class__.StateAlive.Null:
self.setStateAlive(__class__.StateAlive.normal)
def exitStateAlive(self):
self._stateAliveVisit += 1
if self._stateAlive is __class__.StateAlive.normal:
self.exitStateAliveNormal()
self.setStateAlive(__class__.StateAlive.Null)
elif self._stateAlive is __class__.StateAlive.zombie:
self.setStateAlive(__class__.StateAlive.Null)
def setStateAlive(self, aStateAlive):
self._stateAlive = aStateAlive
self._stateAliveVisit += 1
visit = self._stateAliveVisit
if self._state is not __class__.State.alive and aStateAlive is not __class__.StateAlive.Null:
self.setState(__class__.State.alive)
if self._stateAliveVisit != visit:
return
if self._stateAlive is __class__.StateAlive.normal:
if self._stateAliveNormal is __class__.StateAliveNormal.Null:
self.setStateAliveNormal(__class__.StateAliveNormal.baby)
def exitStateAliveNormal(self):
if self._stateAliveNormal is __class__.StateAliveNormal.baby:
self.setStateAliveNormal(__class__.StateAliveNormal.Null)
elif self._stateAliveNormal is __class__.StateAliveNormal.adult:
self.setStateAliveNormal(__class__.StateAliveNormal.Null)
def setStateAliveNormal(self, aStateAliveNormal):
self._stateAliveNormal = aStateAliveNormal
if self._stateAlive is not __class__.StateAlive.normal and aStateAliveNormal is not __class__.StateAliveNormal.Null:
self.setStateAlive(__class__.StateAlive.normal)
def getDrop(self, index):
return self._drops[index]
def getDrops(self):
return tuple(self._drops)
def numberOfDrops(self):
return len(self._drops)
def hasDrops(self):
return len(self._drops) > 0
def indexOfDrop(self, aDrop):
return next((i for i, x in enumerate(self._drops) if x is aDrop), -1)
def getWorld(self):
return self._world
@staticmethod
def minimumNumberOfDrops():
return 0
def addDrop(self, aDrop):
if any(x is aDrop for x in self._drops):
return False
self._drops.append(aDrop)
if aDrop.indexOfAnimal(self) == -1 and not aDrop.addAnimal(self):
del self._drops[next((i for i, x in enumerate(self._drops) if x is aDrop), -1)]
return False
return True
def removeDrop(self, aDrop):
oldIndex = next((i for i, x in enumerate(self._drops) if x is aDrop), -1)
if oldIndex == -1:
return False
del self._drops[oldIndex]
if aDrop.indexOfAnimal(self) != -1 and not aDrop.removeAnimal(self):
self._drops.insert(oldIndex, aDrop)
return False
return True
def addDropAt(self, aDrop, index):
if not self.addDrop(aDrop):
return False
if index < 0:
index = 0
if index > self.numberOfDrops():
index = self.numberOfDrops() - 1
del self._drops[next((i for i, x in enumerate(self._drops) if x is aDrop), -1)]
self._drops.insert(index, aDrop)
return True
def addOrMoveDropAt(self, aDrop, index):
if not any(x is aDrop for x in self._drops):
return self.addDropAt(aDrop, index)
if index < 0:
index = 0
if index > self.numberOfDrops():
index = self.numberOfDrops() - 1
del self._drops[next((i for i, x in enumerate(self._drops) if x is aDrop), -1)]
self._drops.insert(index, aDrop)
return True
def setWorld(self, aWorld):
if aWorld is None:
return False
existingWorld = self._world
self._world = aWorld
if existingWorld is not None and existingWorld is not aWorld:
existingWorld.removeAnimal(self)
self._world.addAnimal(self)
return True
def delete(self):
self._deleted = True
copyOfDrops = tuple(self._drops)
self._drops.clear()
for aDrop in copyOfDrops:
aDrop.removeAnimal(self)
placeholderWorld = self._world
self._world = None
if placeholderWorld is not None:
placeholderWorld.removeAnimal(self)
super().delete()
def __str__(self):
return (super().__str__() + "["
+ "isAlive:" + str(self.getIsAlive())
+ "]"
+ "\n world = " + ("null" if self.getWorld() is None else format(id(self.getWorld()), "x")))
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
def __str__(self):
return self.value
class SmS1(Enum):
Null = "Null"
s1a = "s1a"
s1b = "s1b"
def __str__(self):
return self.value
class Sm1(Enum):
s3 = "s3"
s4 = "s4"
def __str__(self):
return self.value
class Sm2(Enum):
q = "q"
s = "s"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __canProcess(self, call):
name = call.__name__
return (self._sm is __class__.Sm.s1 and name in ("_e1",)
or self._sm is __class__.Sm.s2 and name in ("_e2",)
or self._sm1 is __class__.Sm1.s3 and name in ("_e3",)
or self._sm1 is __class__.Sm1.s4 and name in ("_e4",)
or self._smS1 is __class__.SmS1.s1a and name in ("_e5",)
or self._smS1 is __class__.SmS1.s1b and name in ("_e6",))
def __init__(self):
self.__eventQueue = __class__.MessageQueue(self.__canProcess)
self._sm = None
self._smS1 = None
self._sm1 = None
self._sm2 = None
self._deleted = False
self.setSmS1(__class__.SmS1.Null)
self.setSm(__class__.Sm.s1)
self.setSm1(__class__.Sm1.s3)
self.setSm2(__class__.Sm2.q)
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
if self._smS1 is not __class__.SmS1.Null:
answer += "." + str(self._smS1)
return answer
def getSm1FullName(self):
answer = str(self._sm1)
return answer
def getSm2FullName(self):
answer = str(self._sm2)
return answer
def getSm(self):
return self._sm
def getSm1(self):
return self._sm1
def getSm2(self):
return self._sm2
def getSmS1(self):
return self._smS1
def _e1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.exitSmS1()
self.setSmS1(__class__.SmS1.s1a)
wasEventProcessed = True
return wasEventProcessed
def e1(self):
self.__eventQueue.put(self._e1)
def _e2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def e2(self):
self.__eventQueue.put(self._e2)
def _e3(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1 = self._sm1
if aSm1 is __class__.Sm1.s3:
self.setSm1(__class__.Sm1.s4)
wasEventProcessed = True
return wasEventProcessed
def e3(self):
self.__eventQueue.put(self._e3)
def _e4(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1 = self._sm1
if aSm1 is __class__.Sm1.s4:
self.setSm1(__class__.Sm1.s3)
wasEventProcessed = True
return wasEventProcessed
def e4(self):
self.__eventQueue.put(self._e4)
def _e5(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s1a:
self.exitSmS1()
self.setSmS1(__class__.SmS1.s1b)
wasEventProcessed = True
return wasEventProcessed
def e5(self):
self.__eventQueue.put(self._e5)
def _e6(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s1b:
self.exitSm()
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def e6(self):
self.__eventQueue.put(self._e6)
def exitSm(self):
if self._sm is __class__.Sm.s1:
self.exitSmS1()
def setSm(self, aSm):
self._sm = aSm
if self._sm is __class__.Sm.s1:
if self._smS1 is __class__.SmS1.Null:
self.setSmS1(__class__.SmS1.s1a)
def setSm1(self, aSm1):
self._sm1 = aSm1
def setSm2(self, aSm2):
self._sm2 = aSm2
return True
def exitSmS1(self):
if self._smS1 is __class__.SmS1.s1a:
self.setSmS1(__class__.SmS1.Null)
elif self._smS1 is __class__.SmS1.s1b:
self.setSmS1(__class__.SmS1.Null)
def setSmS1(self, aSmS1):
self._smS1 = aSmS1
if self._sm is not __class__.Sm.s1 and aSmS1 is not __class__.SmS1.Null:
self.setSm(__class__.Sm.s1)
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm1(Enum):
s1 = "s1"
s2 = "s2"
def __str__(self):
return self.value
class Sm2(Enum):
s1 = "s1"
s2 = "s2"
def __str__(self):
return self.value
class TimedEventHandler:
def __init__(self, controller, timeoutMethodName, howLongInSeconds):
self._controller = controller
self._timeoutMethodName = timeoutMethodName
self._timer = threading.Timer(howLongInSeconds, self.run)
self._timer.daemon = False
def start(self):
self._timer.start()
def stop(self):
self._timer.cancel()
def isCurrent(self, handler, state, armedState):
return not self._timer.finished.is_set() and not self._controller._deleted and handler is self and state is armedState
def run(self):
controller = self._controller
if self._timeoutMethodName == "sm1_timeouts1Tos2":
if self.isCurrent(controller._sm1_timeouts1Tos2Handler, controller._sm1, X.Sm1.s1):
if not controller.timeouts1Tos2() and self.isCurrent(controller._sm1_timeouts1Tos2Handler, controller._sm1, X.Sm1.s1):
controller.startSm1_timeouts1Tos2Handler()
elif self._timeoutMethodName == "sm2_timeouts1Tos2":
if self.isCurrent(controller._sm2_timeouts1Tos2Handler, controller._sm2, X.Sm2.s1):
if not controller.timeouts1Tos2() and self.isCurrent(controller._sm2_timeouts1Tos2Handler, controller._sm2, X.Sm2.s1):
controller.startSm2_timeouts1Tos2Handler()
def __init__(self):
self._sm1 = None
self._sm1Visit = 0
self._sm2 = None
self._sm2Visit = 0
self._sm1_timeouts1Tos2Handler = None
self._sm2_timeouts1Tos2Handler = None
self._deleted = False
self.setSm1(__class__.Sm1.s1)
if self._deleted:
return
self.setSm2(__class__.Sm2.s1)
if self._deleted:
return
def getSm1FullName(self):
answer = str(self._sm1)
return answer
def getSm2FullName(self):
answer = str(self._sm2)
return answer
def getSm1(self):
return self._sm1
def getSm2(self):
return self._sm2
def timeouts1Tos2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1 = self._sm1
aSm2 = self._sm2
if aSm1 is __class__.Sm1.s1:
self.exitSm1()
if self._deleted:
return True
self.setSm1(__class__.Sm1.s2)
wasEventProcessed = True
if self._deleted:
return True
if aSm2 is __class__.Sm2.s1:
self.exitSm2()
if self._deleted:
return True
self.setSm2(__class__.Sm2.s2)
wasEventProcessed = True
return wasEventProcessed
def exitSm1(self):
self._sm1Visit += 1
if self._sm1 is __class__.Sm1.s1:
self.stopSm1_timeouts1Tos2Handler()
def setSm1(self, aSm1):
self._sm1 = aSm1
self._sm1Visit += 1
if self._sm1 is __class__.Sm1.s1:
self.startSm1_timeouts1Tos2Handler()
def exitSm2(self):
self._sm2Visit += 1
if self._sm2 is __class__.Sm2.s1:
self.stopSm2_timeouts1Tos2Handler()
def setSm2(self, aSm2):
self._sm2 = aSm2
self._sm2Visit += 1
if self._sm2 is __class__.Sm2.s1:
self.startSm2_timeouts1Tos2Handler()
def startSm1_timeouts1Tos2Handler(self):
if self._deleted:
return
if self._sm1_timeouts1Tos2Handler is not None:
self._sm1_timeouts1Tos2Handler.stop()
visit = self._sm1Visit
delay = 1
if self._deleted or self._sm1Visit != visit:
return
self._sm1_timeouts1Tos2Handler = __class__.TimedEventHandler(self, "sm1_timeouts1Tos2", delay)
self._sm1_timeouts1Tos2Handler.start()
def stopSm1_timeouts1Tos2Handler(self):
if self._sm1_timeouts1Tos2Handler is not None:
self._sm1_timeouts1Tos2Handler.stop()
def startSm2_timeouts1Tos2Handler(self):
if self._deleted:
return
if self._sm2_timeouts1Tos2Handler is not None:
self._sm2_timeouts1Tos2Handler.stop()
visit = self._sm2Visit
delay = 1
if self._deleted or self._sm2Visit != visit:
return
self._sm2_timeouts1Tos2Handler = __class__.TimedEventHandler(self, "sm2_timeouts1Tos2", delay)
self._sm2_timeouts1Tos2Handler.start()
def stopSm2_timeouts1Tos2Handler(self):
if self._sm2_timeouts1Tos2Handler is not None:
self._sm2_timeouts1Tos2Handler.stop()
def delete(self):
self._deleted = True
self.stopSm1_timeouts1Tos2Handler()
self.stopSm2_timeouts1Tos2Handler()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class LightFixture:
class Bulb(Enum):
On = "On"
Off = "Off"
Amber = "Amber"
def __str__(self):
return self.value
def __init__(self):
self._brightness = 0
self._bulb = None
self._deleted = False
self.setBulb(__class__.Bulb.On)
def setBrightness(self, aBrightness):
self._brightness = aBrightness
return True
def getBrightness(self):
return self._brightness
def getBulbFullName(self):
answer = str(self._bulb)
return answer
def getBulb(self):
return self._bulb
def push(self):
if self._deleted:
return False
wasEventProcessed = False
aBulb = self._bulb
if aBulb is __class__.Bulb.On:
if self.getBrightness() < 1:
self.setBulb(__class__.Bulb.Off)
wasEventProcessed = True
elif self.getBrightness() > 10:
self.setBulb(__class__.Bulb.Amber)
wasEventProcessed = True
else:
self.setBulb(__class__.Bulb.On)
wasEventProcessed = True
return wasEventProcessed
def setBulb(self, aBulb):
self._bulb = aBulb
def delete(self):
self._deleted = True
def __str__(self):
return (super().__str__() + "["
+ "brightness:" + str(self.getBrightness())
+ "]")
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class X:
class Status(Enum):
on = "on"
off = "off"
FINAL = "FINAL"
def __str__(self):
return self.value
def __init__(self):
self._status = None
self._deleted = False
self.setStatus(__class__.Status.on)
if self._deleted:
return
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def turnoff(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.on:
self.setStatus(__class__.Status.off)
wasEventProcessed = True
return wasEventProcessed
def powerOff(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.on:
self.setStatus(__class__.Status.FINAL)
wasEventProcessed = True
return wasEventProcessed
def turnOn(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.off:
self.setStatus(__class__.Status.on)
wasEventProcessed = True
return wasEventProcessed
def setStatus(self, aStatus):
self._status = aStatus
if self._status is __class__.Status.FINAL:
self.delete()
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
def __str__(self):
return self.value
class SmS1(Enum):
Null = "Null"
s1a = "s1a"
s1b = "s1b"
def __str__(self):
return self.value
class Sm1(Enum):
s3 = "s3"
s4 = "s4"
def __str__(self):
return self.value
class Sm2(Enum):
q = "q"
s = "s"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __init__(self):
self.__eventQueue = __class__.MessageQueue(None)
self._sm = None
self._smS1 = None
self._sm1 = None
self._sm2 = None
self._deleted = False
self.setSmS1(__class__.SmS1.Null)
self.setSm(__class__.Sm.s1)
self.setSm1(__class__.Sm1.s3)
self.setSm2(__class__.Sm2.q)
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
if self._smS1 is not __class__.SmS1.Null:
answer += "." + str(self._smS1)
return answer
def getSm1FullName(self):
answer = str(self._sm1)
return answer
def getSm2FullName(self):
answer = str(self._sm2)
return answer
def getSm(self):
return self._sm
def getSm1(self):
return self._sm1
def getSm2(self):
return self._sm2
def getSmS1(self):
return self._smS1
def _e1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.exitSmS1()
self.setSmS1(__class__.SmS1.s1a)
wasEventProcessed = True
return wasEventProcessed
def e1(self):
self.__eventQueue.put(self._e1)
def _e2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def e2(self):
self.__eventQueue.put(self._e2)
def _e3(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1 = self._sm1
if aSm1 is __class__.Sm1.s3:
self.setSm1(__class__.Sm1.s4)
wasEventProcessed = True
return wasEventProcessed
def e3(self):
self.__eventQueue.put(self._e3)
def _e4(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1 = self._sm1
if aSm1 is __class__.Sm1.s4:
self.setSm1(__class__.Sm1.s3)
wasEventProcessed = True
return wasEventProcessed
def e4(self):
self.__eventQueue.put(self._e4)
def _e5(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s1a:
self.exitSmS1()
self.setSmS1(__class__.SmS1.s1b)
wasEventProcessed = True
return wasEventProcessed
def e5(self):
self.__eventQueue.put(self._e5)
def _e6(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s1b:
self.exitSm()
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def e6(self):
self.__eventQueue.put(self._e6)
def exitSm(self):
if self._sm is __class__.Sm.s1:
self.exitSmS1()
def setSm(self, aSm):
self._sm = aSm
if self._sm is __class__.Sm.s1:
if self._smS1 is __class__.SmS1.Null:
self.setSmS1(__class__.SmS1.s1a)
def setSm1(self, aSm1):
self._sm1 = aSm1
def setSm2(self, aSm2):
self._sm2 = aSm2
return True
def exitSmS1(self):
if self._smS1 is __class__.SmS1.s1a:
self.setSmS1(__class__.SmS1.Null)
elif self._smS1 is __class__.SmS1.s1b:
self.setSmS1(__class__.SmS1.Null)
def setSmS1(self, aSmS1):
self._smS1 = aSmS1
if self._sm is not __class__.Sm.s1 and aSmS1 is not __class__.SmS1.Null:
self.setSm(__class__.Sm.s1)
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Course:
class Status(Enum):
Open = "Open"
Full = "Full"
def __str__(self):
return self.value
def __init__(self):
self._status = None
self._deleted = False
self.setStatus(__class__.Status.Open)
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def setStatus(self, aStatus):
self._status = aStatus
return True
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class QueuedWithConcurrentStateMachines:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
def __str__(self):
return self.value
class SmS2S2a(Enum):
Null = "Null"
s2a = "s2a"
def __str__(self):
return self.value
class SmS2S2b(Enum):
Null = "Null"
s2b = "s2b"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __init__(self):
self.__eventQueue = __class__.MessageQueue(None)
self._sm = None
self._smVisit = 0
self._smS2S2a = None
self._smS2S2b = None
self._deleted = False
self.setSmS2S2a(__class__.SmS2S2a.Null)
self.setSmS2S2b(__class__.SmS2S2b.Null)
self.setSm(__class__.Sm.s1)
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
if self._smS2S2a is not __class__.SmS2S2a.Null:
answer += "." + str(self._smS2S2a)
if self._smS2S2b is not __class__.SmS2S2b.Null:
answer += "." + str(self._smS2S2b)
return answer
def getSm(self):
return self._sm
def getSmS2S2a(self):
return self._smS2S2a
def getSmS2S2b(self):
return self._smS2S2b
def _e1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def e1(self):
self.__eventQueue.put(self._e1)
def _e2(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS2S2a = self._smS2S2a
aSmS2S2b = self._smS2S2b
if aSmS2S2a is __class__.SmS2S2a.s2a:
self.exitSmS2S2a()
self.setSmS2S2b(__class__.SmS2S2b.s2b)
self.setSmS2S2a(__class__.SmS2S2a.s2a)
wasEventProcessed = True
if aSmS2S2b is __class__.SmS2S2b.s2b:
self.exitSm()
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def e2(self):
self.__eventQueue.put(self._e2)
def exitSm(self):
self._smVisit += 1
if self._sm is __class__.Sm.s2:
self.exitSmS2S2a()
self.exitSmS2S2b()
def setSm(self, aSm):
self._sm = aSm
self._smVisit += 1
visit = self._smVisit
if self._sm is __class__.Sm.s2:
if self._smS2S2a is __class__.SmS2S2a.Null:
self.setSmS2S2a(__class__.SmS2S2a.s2a)
if self._smVisit != visit:
return
if self._smS2S2b is __class__.SmS2S2b.Null:
self.setSmS2S2b(__class__.SmS2S2b.s2b)
def exitSmS2S2a(self):
if self._smS2S2a is __class__.SmS2S2a.s2a:
self.setSmS2S2a(__class__.SmS2S2a.Null)
def setSmS2S2a(self, aSmS2S2a):
self._smS2S2a = aSmS2S2a
if self._sm is not __class__.Sm.s2 and aSmS2S2a is not __class__.SmS2S2a.Null:
self.setSm(__class__.Sm.s2)
def exitSmS2S2b(self):
if self._smS2S2b is __class__.SmS2S2b.s2b:
self.setSmS2S2b(__class__.SmS2S2b.Null)
def setSmS2S2b(self, aSmS2S2b):
self._smS2S2b = aSmS2S2b
if self._sm is not __class__.Sm.s2 and aSmS2S2b is not __class__.SmS2S2b.Null:
self.setSm(__class__.Sm.s2)
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
def __str__(self):
return self.value
class SmS2(Enum):
Null = "Null"
s2a = "s2a"
s2b = "s2b"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __canProcess(self, call):
name = call.__name__
return (self._sm is __class__.Sm.s1 and name in ("_e1", "_e2",)
or self._sm is __class__.Sm.s2 and name in ("_e3",)
or self._smS2 is __class__.SmS2.s2a and name in ("_e4",)
or self._smS2 is __class__.SmS2.s2b and name in ("_e5",))
def __init__(self):
self.__eventQueue = __class__.MessageQueue(self.__canProcess)
self._sm = None
self._smS2 = None
self._deleted = False
self.setSmS2(__class__.SmS2.Null)
self.setSm(__class__.Sm.s1)
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
if self._smS2 is not __class__.SmS2.Null:
answer += "." + str(self._smS2)
return answer
def getSm(self):
return self._sm
def getSmS2(self):
return self._smS2
def _e1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def e1(self):
self.__eventQueue.put(self._e1)
def _e2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.setSmS2(__class__.SmS2.s2b)
wasEventProcessed = True
return wasEventProcessed
def e2(self):
self.__eventQueue.put(self._e2)
def _e3(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self.exitSm()
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def e3(self):
self.__eventQueue.put(self._e3)
def _e4(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS2 = self._smS2
if aSmS2 is __class__.SmS2.s2a:
self.exitSmS2()
self.setSmS2(__class__.SmS2.s2b)
wasEventProcessed = True
return wasEventProcessed
def e4(self):
self.__eventQueue.put(self._e4)
def _e5(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS2 = self._smS2
if aSmS2 is __class__.SmS2.s2b:
self.exitSmS2()
self.setSmS2(__class__.SmS2.s2a)
wasEventProcessed = True
return wasEventProcessed
def e5(self):
self.__eventQueue.put(self._e5)
def exitSm(self):
if self._sm is __class__.Sm.s2:
self.exitSmS2()
def setSm(self, aSm):
self._sm = aSm
if self._sm is __class__.Sm.s2:
if self._smS2 is __class__.SmS2.Null:
self.setSmS2(__class__.SmS2.s2a)
def exitSmS2(self):
if self._smS2 is __class__.SmS2.s2a:
self.setSmS2(__class__.SmS2.Null)
elif self._smS2 is __class__.SmS2.s2b:
self.setSmS2(__class__.SmS2.Null)
def setSmS2(self, aSmS2):
self._smS2 = aSmS2
if self._sm is not __class__.Sm.s2 and aSmS2 is not __class__.SmS2.Null:
self.setSm(__class__.Sm.s2)
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
s3 = "s3"
s4 = "s4"
def __str__(self):
return self.value
class Sm2(Enum):
sm21 = "sm21"
sm22 = "sm22"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __canProcess(self, call):
name = call.__name__
return (self._sm is __class__.Sm.s1 and name in ("_ev1", "_ev5",)
or self._sm is __class__.Sm.s2 and name in ("_ev2",)
or self._sm is __class__.Sm.s3 and name in ("_ev3",)
or self._sm is __class__.Sm.s4 and name in ("_ev4",)
or self._sm2 is __class__.Sm2.sm21 and name in ("_ev1",)
or self._sm2 is __class__.Sm2.sm22 and name in ("_ev7",))
def __init__(self):
self.__eventQueue = __class__.MessageQueue(self.__canProcess)
self._sm = None
self._sm2 = None
self._deleted = False
self.setSm(__class__.Sm.s1)
self.setSm2(__class__.Sm2.sm21)
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
return answer
def getSm2FullName(self):
answer = str(self._sm2)
return answer
def getSm(self):
return self._sm
def getSm2(self):
return self._sm2
def _ev1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
aSm2 = self._sm2
if aSm is __class__.Sm.s1:
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
if aSm2 is __class__.Sm2.sm21:
self.setSm2(__class__.Sm2.sm22)
wasEventProcessed = True
return wasEventProcessed
def ev1(self):
self.__eventQueue.put(self._ev1)
def _ev5(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def ev5(self):
self.__eventQueue.put(self._ev5)
def _ev2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self.setSm(__class__.Sm.s3)
wasEventProcessed = True
return wasEventProcessed
def ev2(self):
self.__eventQueue.put(self._ev2)
def _ev3(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s3:
self.setSm(__class__.Sm.s4)
wasEventProcessed = True
return wasEventProcessed
def ev3(self):
self.__eventQueue.put(self._ev3)
def _ev4(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s4:
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def ev4(self):
self.__eventQueue.put(self._ev4)
def _ev7(self):
if self._deleted:
return False
wasEventProcessed = False
aSm2 = self._sm2
if aSm2 is __class__.Sm2.sm22:
self.setSm2(__class__.Sm2.sm21)
wasEventProcessed = True
return wasEventProcessed
def ev7(self):
self.__eventQueue.put(self._ev7)
def setSm(self, aSm):
self._sm = aSm
def setSm2(self, aSm2):
self._sm2 = aSm2
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class LightFixture:
class Status(Enum):
Off = "Off"
On = "On"
def __str__(self):
return self.value
class StatusOnMotorIdle(Enum):
Null = "Null"
MotorIdle = "MotorIdle"
MotorRunning = "MotorRunning"
def __str__(self):
return self.value
class StatusOnFanIdle(Enum):
Null = "Null"
FanIdle = "FanIdle"
FanRunning = "FanRunning"
def __str__(self):
return self.value
def __init__(self):
self._status = None
self._statusVisit = 0
self._statusOnMotorIdle = None
self._statusOnFanIdle = None
self._deleted = False
self.setStatusOnMotorIdle(__class__.StatusOnMotorIdle.Null)
self.setStatusOnFanIdle(__class__.StatusOnFanIdle.Null)
self.setStatus(__class__.Status.Off)
def getStatusFullName(self):
answer = str(self._status)
if self._statusOnMotorIdle is not __class__.StatusOnMotorIdle.Null:
answer += "." + str(self._statusOnMotorIdle)
if self._statusOnFanIdle is not __class__.StatusOnFanIdle.Null:
answer += "." + str(self._statusOnFanIdle)
return answer
def getStatus(self):
return self._status
def getStatusOnMotorIdle(self):
return self._statusOnMotorIdle
def getStatusOnFanIdle(self):
return self._statusOnFanIdle
def turnOn(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Off:
self.setStatus(__class__.Status.On)
wasEventProcessed = True
return wasEventProcessed
def flip(self):
if self._deleted:
return False
wasEventProcessed = False
aStatusOnMotorIdle = self._statusOnMotorIdle
if aStatusOnMotorIdle is __class__.StatusOnMotorIdle.MotorIdle:
self.exitStatusOnMotorIdle()
self.setStatusOnMotorIdle(__class__.StatusOnMotorIdle.MotorRunning)
wasEventProcessed = True
elif aStatusOnMotorIdle is __class__.StatusOnMotorIdle.MotorRunning:
self.exitStatusOnMotorIdle()
self.setStatusOnMotorIdle(__class__.StatusOnMotorIdle.MotorIdle)
wasEventProcessed = True
return wasEventProcessed
def flop(self):
if self._deleted:
return False
wasEventProcessed = False
aStatusOnFanIdle = self._statusOnFanIdle
if aStatusOnFanIdle is __class__.StatusOnFanIdle.FanIdle:
self.exitStatusOnFanIdle()
self.setStatusOnFanIdle(__class__.StatusOnFanIdle.FanRunning)
wasEventProcessed = True
elif aStatusOnFanIdle is __class__.StatusOnFanIdle.FanRunning:
self.exitStatusOnFanIdle()
self.setStatusOnFanIdle(__class__.StatusOnFanIdle.FanIdle)
wasEventProcessed = True
return wasEventProcessed
def exitStatus(self):
self._statusVisit += 1
if self._status is __class__.Status.On:
self.exitStatusOnMotorIdle()
self.exitStatusOnFanIdle()
def setStatus(self, aStatus):
self._status = aStatus
self._statusVisit += 1
visit = self._statusVisit
if self._status is __class__.Status.On:
if self._statusOnMotorIdle is __class__.StatusOnMotorIdle.Null:
self.setStatusOnMotorIdle(__class__.StatusOnMotorIdle.MotorIdle)
if self._statusVisit != visit:
return
if self._statusOnFanIdle is __class__.StatusOnFanIdle.Null:
self.setStatusOnFanIdle(__class__.StatusOnFanIdle.FanIdle)
def exitStatusOnMotorIdle(self):
if self._statusOnMotorIdle is __class__.StatusOnMotorIdle.MotorIdle:
self.setStatusOnMotorIdle(__class__.StatusOnMotorIdle.Null)
elif self._statusOnMotorIdle is __class__.StatusOnMotorIdle.MotorRunning:
self.setStatusOnMotorIdle(__class__.StatusOnMotorIdle.Null)
def setStatusOnMotorIdle(self, aStatusOnMotorIdle):
self._statusOnMotorIdle = aStatusOnMotorIdle
if self._status is not __class__.Status.On and aStatusOnMotorIdle is not __class__.StatusOnMotorIdle.Null:
self.setStatus(__class__.Status.On)
def exitStatusOnFanIdle(self):
if self._statusOnFanIdle is __class__.StatusOnFanIdle.FanIdle:
self.setStatusOnFanIdle(__class__.StatusOnFanIdle.Null)
elif self._statusOnFanIdle is __class__.StatusOnFanIdle.FanRunning:
self.setStatusOnFanIdle(__class__.StatusOnFanIdle.Null)
def setStatusOnFanIdle(self, aStatusOnFanIdle):
self._statusOnFanIdle = aStatusOnFanIdle
if self._status is not __class__.Status.On and aStatusOnFanIdle is not __class__.StatusOnFanIdle.Null:
self.setStatus(__class__.Status.On)
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Light:
class Status(Enum):
On = "On"
Off = "Off"
def __str__(self):
return self.value
def __init__(self):
self._status = None
self._deleted = False
self.setStatus(__class__.Status.On)
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def flip(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.On:
self.setStatus(__class__.Status.Off)
wasEventProcessed = True
return wasEventProcessed
def setStatus(self, aStatus):
self._status = aStatus
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
s3 = "s3"
def __str__(self):
return self.value
class TimedEventHandler:
def __init__(self, controller, timeoutMethodName, howLongInSeconds):
self._controller = controller
self._timeoutMethodName = timeoutMethodName
self._timer = threading.Timer(howLongInSeconds, self.run)
self._timer.daemon = False
def start(self):
self._timer.start()
def stop(self):
self._timer.cancel()
def isCurrent(self, handler, state, armedState):
return not self._timer.finished.is_set() and not self._controller._deleted and handler is self and state is armedState
def run(self):
controller = self._controller
if self._timeoutMethodName == "timeouts2Tos3":
if self.isCurrent(controller._timeouts2Tos3Handler, controller._sm, X.Sm.s2):
if not controller.timeouts2Tos3() and self.isCurrent(controller._timeouts2Tos3Handler, controller._sm, X.Sm.s2):
controller.startTimeouts2Tos3Handler()
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __canProcess(self, call):
name = call.__name__
return (self._sm is __class__.Sm.s2 and name in ("_timeouts2Tos3",))
def __init__(self):
self.__eventQueue = __class__.MessageQueue(self.__canProcess)
self._sm = None
self._smVisit = 0
self._timeouts2Tos3Handler = None
self._deleted = False
self.setSm(__class__.Sm.s1)
if self._deleted:
return
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
return answer
def getSm(self):
return self._sm
def __autotransition1__(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.setSm(__class__.Sm.s3)
wasEventProcessed = True
return wasEventProcessed
def _timeouts2Tos3(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.s3)
wasEventProcessed = True
return wasEventProcessed
def timeouts2Tos3(self):
self.__eventQueue.put(self._timeouts2Tos3)
return True
def exitSm(self):
self._smVisit += 1
if self._sm is __class__.Sm.s2:
self.stopTimeouts2Tos3Handler()
def setSm(self, aSm):
self._sm = aSm
self._smVisit += 1
if self._sm is __class__.Sm.s1:
self.__autotransition1__()
elif self._sm is __class__.Sm.s2:
self.startTimeouts2Tos3Handler()
def startTimeouts2Tos3Handler(self):
if self._deleted:
return
if self._timeouts2Tos3Handler is not None:
self._timeouts2Tos3Handler.stop()
visit = self._smVisit
delay = 10
if self._deleted or self._smVisit != visit:
return
self._timeouts2Tos3Handler = __class__.TimedEventHandler(self, "timeouts2Tos3", delay)
self._timeouts2Tos3Handler.start()
def stopTimeouts2Tos3Handler(self):
if self._timeouts2Tos3Handler is not None:
self._timeouts2Tos3Handler.stop()
def delete(self):
self._deleted = True
self.stopTimeouts2Tos3Handler()
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Garage:
class GarageDoor(Enum):
def __str__(self):
return self.value
def __init__(self):
self._garageDoor = None
self._deleted = False
def getGarageDoorFullName(self):
answer = str(self._garageDoor)
return answer
def getGarageDoor(self):
return self._garageDoor
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class stateMachineWithStringComparisonGuard:
class CommandControl(Enum):
IDLE = "IDLE"
CHECK_AVAILABILITY = "CHECK_AVAILABILITY"
COMMAND_VALIDITY = "COMMAND_VALIDITY"
EXECUTION = "EXECUTION"
def __str__(self):
return self.value
def __init__(self):
self._cmdString = ""
self._commandControl = None
self._deleted = False
self.setCommandControl(__class__.CommandControl.IDLE)
def setCmdString(self, aCmdString):
self._cmdString = aCmdString
return True
def getCmdString(self):
return self._cmdString
def getCommandControlFullName(self):
answer = str(self._commandControl)
return answer
def getCommandControl(self):
return self._commandControl
def execute(self):
if self._deleted:
return False
wasEventProcessed = False
aCommandControl = self._commandControl
if aCommandControl is __class__.CommandControl.IDLE:
self.setCommandControl(__class__.CommandControl.CHECK_AVAILABILITY)
wasEventProcessed = True
elif aCommandControl is __class__.CommandControl.CHECK_AVAILABILITY:
if "" != self.getCmdString():
self.setCommandControl(__class__.CommandControl.COMMAND_VALIDITY)
wasEventProcessed = True
elif aCommandControl is __class__.CommandControl.COMMAND_VALIDITY:
if self.isCommandValid(self.getCmdString()):
self.setCommandControl(__class__.CommandControl.EXECUTION)
wasEventProcessed = True
return wasEventProcessed
def setCommandControl(self, aCommandControl):
self._commandControl = aCommandControl
def delete(self):
self._deleted = True
def __str__(self):
return (super().__str__() + "["
+ "cmdString:" + str(self.getCmdString())
+ "]")
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from abc import ABC
class IX(ABC):
pass
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from example.IX import IX
from enum import Enum
import threading
class X(IX):
class Sm(Enum):
s1 = "s1"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __init__(self):
self.__eventQueue = __class__.MessageQueue(None)
self._sm = None
self._deleted = False
self.setSm(__class__.Sm.s1)
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
return answer
def getSm(self):
return self._sm
def _e(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def e(self):
self.__eventQueue.put(self._e)
def setSm(self, aSm):
self._sm = aSm
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
def __str__(self):
return self.value
class SmS1(Enum):
Null = "Null"
s1a = "s1a"
s1b = "s1b"
def __str__(self):
return self.value
class Sm1(Enum):
s3 = "s3"
s4 = "s4"
def __str__(self):
return self.value
class Sm1S4(Enum):
Null = "Null"
s4a = "s4a"
s4b = "s4b"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __canProcess(self, call):
name = call.__name__
return (self._sm is __class__.Sm.s1 and name in ("_e1",)
or self._sm is __class__.Sm.s2 and name in ("_e2",)
or self._sm1 is __class__.Sm1.s3 and name in ("_e3",)
or self._sm1 is __class__.Sm1.s4 and name in ("_e4",)
or self._smS1 is __class__.SmS1.s1a and name in ("_e5",)
or self._smS1 is __class__.SmS1.s1b and name in ("_e6",)
or self._sm1S4 is __class__.Sm1S4.s4a and name in ("_e7",)
or self._sm1S4 is __class__.Sm1S4.s4b and name in ("_e8",))
def __init__(self):
self.__eventQueue = __class__.MessageQueue(self.__canProcess)
self._sm = None
self._smS1 = None
self._sm1 = None
self._sm1S4 = None
self._deleted = False
self.setSmS1(__class__.SmS1.Null)
self.setSm(__class__.Sm.s1)
self.setSm1S4(__class__.Sm1S4.Null)
self.setSm1(__class__.Sm1.s3)
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
if self._smS1 is not __class__.SmS1.Null:
answer += "." + str(self._smS1)
return answer
def getSm1FullName(self):
answer = str(self._sm1)
if self._sm1S4 is not __class__.Sm1S4.Null:
answer += "." + str(self._sm1S4)
return answer
def getSm(self):
return self._sm
def getSm1(self):
return self._sm1
def getSmS1(self):
return self._smS1
def getSm1S4(self):
return self._sm1S4
def _e1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.exitSmS1()
self.setSmS1(__class__.SmS1.s1a)
wasEventProcessed = True
return wasEventProcessed
def e1(self):
self.__eventQueue.put(self._e1)
def _e2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def e2(self):
self.__eventQueue.put(self._e2)
def _e3(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1 = self._sm1
if aSm1 is __class__.Sm1.s3:
self.setSm1(__class__.Sm1.s4)
wasEventProcessed = True
return wasEventProcessed
def e3(self):
self.__eventQueue.put(self._e3)
def _e4(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1 = self._sm1
if aSm1 is __class__.Sm1.s4:
self.exitSm1S4()
self.setSm1S4(__class__.Sm1S4.s4a)
wasEventProcessed = True
return wasEventProcessed
def e4(self):
self.__eventQueue.put(self._e4)
def _e5(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s1a:
self.exitSmS1()
self.setSmS1(__class__.SmS1.s1b)
wasEventProcessed = True
return wasEventProcessed
def e5(self):
self.__eventQueue.put(self._e5)
def _e6(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s1b:
self.exitSm()
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def e6(self):
self.__eventQueue.put(self._e6)
def _e7(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1S4 = self._sm1S4
if aSm1S4 is __class__.Sm1S4.s4a:
self.exitSm1S4()
self.setSm1S4(__class__.Sm1S4.s4b)
wasEventProcessed = True
return wasEventProcessed
def e7(self):
self.__eventQueue.put(self._e7)
def _e8(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1S4 = self._sm1S4
if aSm1S4 is __class__.Sm1S4.s4b:
self.exitSm1()
self.setSm1(__class__.Sm1.s3)
wasEventProcessed = True
return wasEventProcessed
def e8(self):
self.__eventQueue.put(self._e8)
def exitSm(self):
if self._sm is __class__.Sm.s1:
self.exitSmS1()
def setSm(self, aSm):
self._sm = aSm
if self._sm is __class__.Sm.s1:
if self._smS1 is __class__.SmS1.Null:
self.setSmS1(__class__.SmS1.s1a)
def exitSm1(self):
if self._sm1 is __class__.Sm1.s4:
self.exitSm1S4()
def setSm1(self, aSm1):
self._sm1 = aSm1
if self._sm1 is __class__.Sm1.s4:
if self._sm1S4 is __class__.Sm1S4.Null:
self.setSm1S4(__class__.Sm1S4.s4a)
def exitSmS1(self):
if self._smS1 is __class__.SmS1.s1a:
self.setSmS1(__class__.SmS1.Null)
elif self._smS1 is __class__.SmS1.s1b:
self.setSmS1(__class__.SmS1.Null)
def setSmS1(self, aSmS1):
self._smS1 = aSmS1
if self._sm is not __class__.Sm.s1 and aSmS1 is not __class__.SmS1.Null:
self.setSm(__class__.Sm.s1)
def exitSm1S4(self):
if self._sm1S4 is __class__.Sm1S4.s4a:
self.setSm1S4(__class__.Sm1S4.Null)
elif self._sm1S4 is __class__.Sm1S4.s4b:
self.setSm1S4(__class__.Sm1S4.Null)
def setSm1S4(self, aSm1S4):
self._sm1S4 = aSm1S4
if self._sm1 is not __class__.Sm1.s4 and aSm1S4 is not __class__.Sm1S4.Null:
self.setSm1(__class__.Sm1.s4)
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class QueuedWithNestedStateMachines:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
def __str__(self):
return self.value
class SmS2(Enum):
Null = "Null"
s2a = "s2a"
s2b = "s2b"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __init__(self):
self.__eventQueue = __class__.MessageQueue(None)
self._sm = None
self._smS2 = None
self._deleted = False
self.setSmS2(__class__.SmS2.Null)
self.setSm(__class__.Sm.s1)
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
if self._smS2 is not __class__.SmS2.Null:
answer += "." + str(self._smS2)
return answer
def getSm(self):
return self._sm
def getSmS2(self):
return self._smS2
def _e1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def e1(self):
self.__eventQueue.put(self._e1)
def _e2(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS2 = self._smS2
if aSmS2 is __class__.SmS2.s2a:
self.exitSmS2()
self.setSmS2(__class__.SmS2.s2b)
wasEventProcessed = True
return wasEventProcessed
def e2(self):
self.__eventQueue.put(self._e2)
def _e3(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS2 = self._smS2
if aSmS2 is __class__.SmS2.s2b:
self.exitSmS2()
self.setSmS2(__class__.SmS2.s2a)
wasEventProcessed = True
return wasEventProcessed
def e3(self):
self.__eventQueue.put(self._e3)
def exitSm(self):
if self._sm is __class__.Sm.s2:
self.exitSmS2()
def setSm(self, aSm):
self._sm = aSm
if self._sm is __class__.Sm.s2:
if self._smS2 is __class__.SmS2.Null:
self.setSmS2(__class__.SmS2.s2a)
def exitSmS2(self):
if self._smS2 is __class__.SmS2.s2a:
self.setSmS2(__class__.SmS2.Null)
elif self._smS2 is __class__.SmS2.s2b:
self.setSmS2(__class__.SmS2.Null)
def setSmS2(self, aSmS2):
self._smS2 = aSmS2
if self._sm is not __class__.Sm.s2 and aSmS2 is not __class__.SmS2.Null:
self.setSm(__class__.Sm.s2)
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class X:
class Sm(Enum):
s0 = "s0"
s1 = "s1"
def __str__(self):
return self.value
class SmS0T1(Enum):
Null = "Null"
t1 = "t1"
def __str__(self):
return self.value
class SmS0T2(Enum):
Null = "Null"
t2 = "t2"
t3 = "t3"
def __str__(self):
return self.value
class SmS1(Enum):
Null = "Null"
s2 = "s2"
s3 = "s3"
def __str__(self):
return self.value
class SmS1S2T1(Enum):
Null = "Null"
t1 = "t1"
t4 = "t4"
def __str__(self):
return self.value
class SmS1S2T6(Enum):
Null = "Null"
t6 = "t6"
def __str__(self):
return self.value
class SmS1S2T2(Enum):
Null = "Null"
t2 = "t2"
t5 = "t5"
def __str__(self):
return self.value
class SmS1S3T7(Enum):
Null = "Null"
t7 = "t7"
t8 = "t8"
def __str__(self):
return self.value
class SmS1S3T6(Enum):
Null = "Null"
t6 = "t6"
t9 = "t9"
def __str__(self):
return self.value
def __init__(self):
self._sm = None
self._smVisit = 0
self._smS0T1 = None
self._smS0T2 = None
self._smS1 = None
self._smS1Visit = 0
self._smS1S2T1 = None
self._smS1S2T6 = None
self._smS1S2T2 = None
self._smS1S3T7 = None
self._smS1S3T6 = None
self._deleted = False
self.setSmS0T1(__class__.SmS0T1.Null)
self.setSmS0T2(__class__.SmS0T2.Null)
self.setSmS1(__class__.SmS1.Null)
self.setSmS1S2T1(__class__.SmS1S2T1.Null)
self.setSmS1S2T6(__class__.SmS1S2T6.Null)
self.setSmS1S2T2(__class__.SmS1S2T2.Null)
self.setSmS1S3T7(__class__.SmS1S3T7.Null)
self.setSmS1S3T6(__class__.SmS1S3T6.Null)
self.setSm(__class__.Sm.s0)
def getSmFullName(self):
answer = str(self._sm)
if self._smS0T1 is not __class__.SmS0T1.Null:
answer += "." + str(self._smS0T1)
if self._smS0T2 is not __class__.SmS0T2.Null:
answer += "." + str(self._smS0T2)
if self._smS1 is not __class__.SmS1.Null:
answer += "." + str(self._smS1)
if self._smS1S2T1 is not __class__.SmS1S2T1.Null:
answer += "." + str(self._smS1S2T1)
if self._smS1S2T6 is not __class__.SmS1S2T6.Null:
answer += "." + str(self._smS1S2T6)
if self._smS1S2T2 is not __class__.SmS1S2T2.Null:
answer += "." + str(self._smS1S2T2)
if self._smS1S3T7 is not __class__.SmS1S3T7.Null:
answer += "." + str(self._smS1S3T7)
if self._smS1S3T6 is not __class__.SmS1S3T6.Null:
answer += "." + str(self._smS1S3T6)
return answer
def getSm(self):
return self._sm
def getSmS0T1(self):
return self._smS0T1
def getSmS0T2(self):
return self._smS0T2
def getSmS1(self):
return self._smS1
def getSmS1S2T1(self):
return self._smS1S2T1
def getSmS1S2T6(self):
return self._smS1S2T6
def getSmS1S2T2(self):
return self._smS1S2T2
def getSmS1S3T7(self):
return self._smS1S3T7
def getSmS1S3T6(self):
return self._smS1S3T6
def goS1(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS0T1 = self._smS0T1
aSmS0T2 = self._smS0T2
if aSmS0T1 is __class__.SmS0T1.t1:
self.exitSm()
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
if aSmS0T2 is __class__.SmS0T2.t2:
self.exitSm()
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def goT4(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1S2T1 = self._smS1S2T1
if aSmS1S2T1 is __class__.SmS1S2T1.t1:
self.exitSmS1S2T1()
self.setSmS1S2T1(__class__.SmS1S2T1.t4)
wasEventProcessed = True
return wasEventProcessed
def goT5(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1S2T6 = self._smS1S2T6
aSmS1S2T2 = self._smS1S2T2
if aSmS1S2T6 is __class__.SmS1S2T6.t6:
self.exitSmS1S2T6()
self.setSmS1S2T2(__class__.SmS1S2T2.t5)
self.setSmS1S2T6(__class__.SmS1S2T6.t6)
wasEventProcessed = True
if aSmS1S2T2 is __class__.SmS1S2T2.t2:
self.exitSmS1S2T2()
self.setSmS1S2T2(__class__.SmS1S2T2.t5)
wasEventProcessed = True
return wasEventProcessed
def goT8(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1S3T7 = self._smS1S3T7
if aSmS1S3T7 is __class__.SmS1S3T7.t7:
self.exitSmS1S3T7()
self.setSmS1S3T7(__class__.SmS1S3T7.t8)
wasEventProcessed = True
return wasEventProcessed
def goT9(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1S3T6 = self._smS1S3T6
if aSmS1S3T6 is __class__.SmS1S3T6.t6:
self.exitSmS1S3T6()
self.setSmS1S3T6(__class__.SmS1S3T6.t9)
wasEventProcessed = True
return wasEventProcessed
def exitSm(self):
self._smVisit += 1
if self._sm is __class__.Sm.s0:
self.exitSmS0T1()
self.exitSmS0T2()
elif self._sm is __class__.Sm.s1:
self.exitSmS1()
def setSm(self, aSm):
self._sm = aSm
self._smVisit += 1
visit = self._smVisit
if self._sm is __class__.Sm.s0:
if self._smS0T1 is __class__.SmS0T1.Null:
self.setSmS0T1(__class__.SmS0T1.t1)
if self._smVisit != visit:
return
if self._smS0T2 is __class__.SmS0T2.Null:
self.setSmS0T2(__class__.SmS0T2.t2)
elif self._sm is __class__.Sm.s1:
if self._smS1 is __class__.SmS1.Null:
self.setSmS1(__class__.SmS1.s2)
def exitSmS0T1(self):
if self._smS0T1 is __class__.SmS0T1.t1:
self.setSmS0T1(__class__.SmS0T1.Null)
def setSmS0T1(self, aSmS0T1):
self._smS0T1 = aSmS0T1
if self._sm is not __class__.Sm.s0 and aSmS0T1 is not __class__.SmS0T1.Null:
self.setSm(__class__.Sm.s0)
def exitSmS0T2(self):
if self._smS0T2 is __class__.SmS0T2.t2:
self.setSmS0T2(__class__.SmS0T2.Null)
elif self._smS0T2 is __class__.SmS0T2.t3:
self.setSmS0T2(__class__.SmS0T2.Null)
def setSmS0T2(self, aSmS0T2):
self._smS0T2 = aSmS0T2
if self._sm is not __class__.Sm.s0 and aSmS0T2 is not __class__.SmS0T2.Null:
self.setSm(__class__.Sm.s0)
def exitSmS1(self):
self._smS1Visit += 1
if self._smS1 is __class__.SmS1.s2:
self.exitSmS1S2T1()
self.exitSmS1S2T6()
self.exitSmS1S2T2()
self.setSmS1(__class__.SmS1.Null)
elif self._smS1 is __class__.SmS1.s3:
self.exitSmS1S3T7()
self.exitSmS1S3T6()
self.setSmS1(__class__.SmS1.Null)
def setSmS1(self, aSmS1):
self._smS1 = aSmS1
self._smS1Visit += 1
visit = self._smS1Visit
if self._sm is not __class__.Sm.s1 and aSmS1 is not __class__.SmS1.Null:
self.setSm(__class__.Sm.s1)
if self._smS1Visit != visit:
return
if self._smS1 is __class__.SmS1.s2:
if self._smS1S2T1 is __class__.SmS1S2T1.Null:
self.setSmS1S2T1(__class__.SmS1S2T1.t1)
if self._smS1Visit != visit:
return
if self._smS1S2T6 is __class__.SmS1S2T6.Null:
self.setSmS1S2T6(__class__.SmS1S2T6.t6)
if self._smS1Visit != visit:
return
if self._smS1S2T2 is __class__.SmS1S2T2.Null:
self.setSmS1S2T2(__class__.SmS1S2T2.t2)
elif self._smS1 is __class__.SmS1.s3:
if self._smS1S3T7 is __class__.SmS1S3T7.Null:
self.setSmS1S3T7(__class__.SmS1S3T7.t7)
if self._smS1Visit != visit:
return
if self._smS1S3T6 is __class__.SmS1S3T6.Null:
self.setSmS1S3T6(__class__.SmS1S3T6.t6)
def exitSmS1S2T1(self):
if self._smS1S2T1 is __class__.SmS1S2T1.t1:
self.setSmS1S2T1(__class__.SmS1S2T1.Null)
elif self._smS1S2T1 is __class__.SmS1S2T1.t4:
self.setSmS1S2T1(__class__.SmS1S2T1.Null)
def setSmS1S2T1(self, aSmS1S2T1):
self._smS1S2T1 = aSmS1S2T1
if self._smS1 is not __class__.SmS1.s2 and aSmS1S2T1 is not __class__.SmS1S2T1.Null:
self.setSmS1(__class__.SmS1.s2)
def exitSmS1S2T6(self):
if self._smS1S2T6 is __class__.SmS1S2T6.t6:
self.setSmS1S2T6(__class__.SmS1S2T6.Null)
def setSmS1S2T6(self, aSmS1S2T6):
self._smS1S2T6 = aSmS1S2T6
if self._smS1 is not __class__.SmS1.s2 and aSmS1S2T6 is not __class__.SmS1S2T6.Null:
self.setSmS1(__class__.SmS1.s2)
def exitSmS1S2T2(self):
if self._smS1S2T2 is __class__.SmS1S2T2.t2:
self.setSmS1S2T2(__class__.SmS1S2T2.Null)
elif self._smS1S2T2 is __class__.SmS1S2T2.t5:
self.setSmS1S2T2(__class__.SmS1S2T2.Null)
def setSmS1S2T2(self, aSmS1S2T2):
self._smS1S2T2 = aSmS1S2T2
if self._smS1 is not __class__.SmS1.s2 and aSmS1S2T2 is not __class__.SmS1S2T2.Null:
self.setSmS1(__class__.SmS1.s2)
def exitSmS1S3T7(self):
if self._smS1S3T7 is __class__.SmS1S3T7.t7:
self.setSmS1S3T7(__class__.SmS1S3T7.Null)
elif self._smS1S3T7 is __class__.SmS1S3T7.t8:
self.setSmS1S3T7(__class__.SmS1S3T7.Null)
def setSmS1S3T7(self, aSmS1S3T7):
self._smS1S3T7 = aSmS1S3T7
if self._smS1 is not __class__.SmS1.s3 and aSmS1S3T7 is not __class__.SmS1S3T7.Null:
self.setSmS1(__class__.SmS1.s3)
def exitSmS1S3T6(self):
if self._smS1S3T6 is __class__.SmS1S3T6.t6:
self.setSmS1S3T6(__class__.SmS1S3T6.Null)
elif self._smS1S3T6 is __class__.SmS1S3T6.t9:
self.setSmS1S3T6(__class__.SmS1S3T6.Null)
def setSmS1S3T6(self, aSmS1S3T6):
self._smS1S3T6 = aSmS1S3T6
if self._smS1 is not __class__.SmS1.s3 and aSmS1S3T6 is not __class__.SmS1S3T6.Null:
self.setSmS1(__class__.SmS1.s3)
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Light:
class Bulb(Enum):
Off = "Off"
On = "On"
def __str__(self):
return self.value
def __init__(self):
self._bulb = None
self._deleted = False
self.setBulb(__class__.Bulb.Off)
def getBulbFullName(self):
answer = str(self._bulb)
return answer
def getBulb(self):
return self._bulb
def flip(self):
if self._deleted:
return False
wasEventProcessed = False
aBulb = self._bulb
if aBulb is __class__.Bulb.Off:
self.setBulb(__class__.Bulb.On)
wasEventProcessed = True
elif aBulb is __class__.Bulb.On:
self.setBulb(__class__.Bulb.Off)
wasEventProcessed = True
return wasEventProcessed
def setBulb(self, aBulb):
self._bulb = aBulb
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Animal:
class State(Enum):
alive = "alive"
dead = "dead"
def __str__(self):
return self.value
class StateAlive(Enum):
Null = "Null"
normal = "normal"
zombie = "zombie"
def __str__(self):
return self.value
def __init__(self, aIsAlive):
self._isAlive = aIsAlive
self._state = None
self._stateAlive = None
self._deleted = False
self.setStateAlive(__class__.StateAlive.Null)
self.setState(__class__.State.alive)
def setIsAlive(self, aIsAlive):
self._isAlive = aIsAlive
return True
def getIsAlive(self):
return self._isAlive
def isIsAlive(self):
return self._isAlive
def getStateFullName(self):
answer = str(self._state)
if self._stateAlive is not __class__.StateAlive.Null:
answer += "." + str(self._stateAlive)
return answer
def getState(self):
return self._state
def getStateAlive(self):
return self._stateAlive
def kill(self):
if self._deleted:
return False
wasEventProcessed = False
aState = self._state
if aState is __class__.State.alive:
self.exitState()
self.setState(__class__.State.dead)
wasEventProcessed = True
return wasEventProcessed
def zombify(self):
if self._deleted:
return False
wasEventProcessed = False
aStateAlive = self._stateAlive
if aStateAlive is __class__.StateAlive.normal:
self.exitStateAlive()
self.setStateAlive(__class__.StateAlive.zombie)
wasEventProcessed = True
return wasEventProcessed
def haveBaby(self):
if self._deleted:
return False
wasEventProcessed = False
aStateAlive = self._stateAlive
if aStateAlive is __class__.StateAlive.zombie:
self.exitStateAlive()
self.setStateAlive(__class__.StateAlive.normal)
wasEventProcessed = True
return wasEventProcessed
def exitState(self):
if self._state is __class__.State.alive:
self.exitStateAlive()
def setState(self, aState):
self._state = aState
if self._state is __class__.State.alive:
if self._stateAlive is __class__.StateAlive.Null:
self.setStateAlive(__class__.StateAlive.normal)
def exitStateAlive(self):
if self._stateAlive is __class__.StateAlive.normal:
self.setStateAlive(__class__.StateAlive.Null)
elif self._stateAlive is __class__.StateAlive.zombie:
self.setStateAlive(__class__.StateAlive.Null)
def setStateAlive(self, aStateAlive):
self._stateAlive = aStateAlive
if self._state is not __class__.State.alive and aStateAlive is not __class__.StateAlive.Null:
self.setState(__class__.State.alive)
def delete(self):
self._deleted = True
def __str__(self):
return (super().__str__() + "["
+ "isAlive:" + str(self.getIsAlive())
+ "]")
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Course:
class Status(Enum):
Open = "Open"
def __str__(self):
return self.value
def __init__(self):
self._status = None
self._deleted = False
self.setStatus(__class__.Status.Open)
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def register(self, name, age, grades):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Open:
self.setStatus(__class__.Status.Open)
wasEventProcessed = True
return wasEventProcessed
def setStatus(self, aStatus):
self._status = aStatus
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Mentor:
class Status(Enum):
def __str__(self):
return self.value
def __init__(self):
self._status = None
self._deleted = False
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class GarageDoor:
class Status(Enum):
Open = "Open"
Closing = "Closing"
Closed = "Closed"
Opening = "Opening"
HalfOpen = "HalfOpen"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __init__(self):
self.__eventQueue = __class__.MessageQueue(None)
self._status = None
self._deleted = False
self.setStatus(__class__.Status.Open)
self.__eventQueue.start()
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def _buttonOrObstacle(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Open:
self.setStatus(__class__.Status.Closing)
wasEventProcessed = True
elif aStatus is __class__.Status.Closing:
self.setStatus(__class__.Status.Opening)
wasEventProcessed = True
elif aStatus is __class__.Status.Closed:
self.setStatus(__class__.Status.Opening)
wasEventProcessed = True
elif aStatus is __class__.Status.Opening:
self.setStatus(__class__.Status.HalfOpen)
wasEventProcessed = True
elif aStatus is __class__.Status.HalfOpen:
self.setStatus(__class__.Status.Opening)
wasEventProcessed = True
return wasEventProcessed
def buttonOrObstacle(self):
self.__eventQueue.put(self._buttonOrObstacle)
def _reachBottom(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Closing:
self.setStatus(__class__.Status.Closed)
wasEventProcessed = True
return wasEventProcessed
def reachBottom(self):
self.__eventQueue.put(self._reachBottom)
def _reachTop(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Opening:
self.setStatus(__class__.Status.Open)
wasEventProcessed = True
return wasEventProcessed
def reachTop(self):
self.__eventQueue.put(self._reachTop)
def setStatus(self, aStatus):
self._status = aStatus
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
def __str__(self):
return self.value
class SmS1(Enum):
Null = "Null"
s1a = "s1a"
s1b = "s1b"
def __str__(self):
return self.value
class SmS2(Enum):
Null = "Null"
s2a = "s2a"
s2b = "s2b"
def __str__(self):
return self.value
class TimedEventHandler:
def __init__(self, controller, timeoutMethodName, howLongInSeconds):
self._controller = controller
self._timeoutMethodName = timeoutMethodName
self._timer = threading.Timer(howLongInSeconds, self.run)
self._timer.daemon = False
def start(self):
self._timer.start()
def stop(self):
self._timer.cancel()
def isCurrent(self, handler, state, armedState):
return not self._timer.finished.is_set() and not self._controller._deleted and handler is self and state is armedState
def run(self):
controller = self._controller
if self._timeoutMethodName == "timeouts1aTos1b":
if self.isCurrent(controller._timeouts1aTos1bHandler, controller._smS1, X.SmS1.s1a):
if not controller.timeouts1aTos1b() and self.isCurrent(controller._timeouts1aTos1bHandler, controller._smS1, X.SmS1.s1a):
controller.startTimeouts1aTos1bHandler()
elif self._timeoutMethodName == "timeouts2bTos1b":
if self.isCurrent(controller._timeouts2bTos1bHandler, controller._smS2, X.SmS2.s2b):
if not controller.timeouts2bTos1b() and self.isCurrent(controller._timeouts2bTos1bHandler, controller._smS2, X.SmS2.s2b):
controller.startTimeouts2bTos1bHandler()
def __init__(self):
self._sm = None
self._smS1 = None
self._smS1Visit = 0
self._smS2 = None
self._smS2Visit = 0
self._timeouts1aTos1bHandler = None
self._timeouts2bTos1bHandler = None
self._deleted = False
self.setSmS1(__class__.SmS1.Null)
if self._deleted:
return
self.setSmS2(__class__.SmS2.Null)
if self._deleted:
return
self.setSm(__class__.Sm.s1)
if self._deleted:
return
def getSmFullName(self):
answer = str(self._sm)
if self._smS1 is not __class__.SmS1.Null:
answer += "." + str(self._smS1)
if self._smS2 is not __class__.SmS2.Null:
answer += "." + str(self._smS2)
return answer
def getSm(self):
return self._sm
def getSmS1(self):
return self._smS1
def getSmS2(self):
return self._smS2
def timeouts1aTos1b(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s1a:
self.exitSmS1()
if self._deleted:
return True
self.setSmS1(__class__.SmS1.s1b)
wasEventProcessed = True
return wasEventProcessed
def e1(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s1b:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def e2(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS2 = self._smS2
if aSmS2 is __class__.SmS2.s2a:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def timeouts2bTos1b(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS2 = self._smS2
if aSmS2 is __class__.SmS2.s2b:
self.exitSm()
if self._deleted:
return True
self.setSmS1(__class__.SmS1.s1b)
wasEventProcessed = True
return wasEventProcessed
def exitSm(self):
if self._sm is __class__.Sm.s1:
self.exitSmS1()
elif self._sm is __class__.Sm.s2:
self.exitSmS2()
def setSm(self, aSm):
self._sm = aSm
if self._sm is __class__.Sm.s1:
if self._smS1 is __class__.SmS1.Null:
self.setSmS1(__class__.SmS1.s1a)
elif self._sm is __class__.Sm.s2:
if self._smS2 is __class__.SmS2.Null:
self.setSmS2(__class__.SmS2.s2a)
def exitSmS1(self):
self._smS1Visit += 1
if self._smS1 is __class__.SmS1.s1a:
self.setSmS1(__class__.SmS1.Null)
if self._deleted:
return
self.stopTimeouts1aTos1bHandler()
elif self._smS1 is __class__.SmS1.s1b:
self.setSmS1(__class__.SmS1.Null)
def setSmS1(self, aSmS1):
self._smS1 = aSmS1
self._smS1Visit += 1
visit = self._smS1Visit
if self._sm is not __class__.Sm.s1 and aSmS1 is not __class__.SmS1.Null:
self.setSm(__class__.Sm.s1)
if self._deleted or self._smS1Visit != visit:
return
if self._smS1 is __class__.SmS1.s1a:
self.startTimeouts1aTos1bHandler()
def exitSmS2(self):
self._smS2Visit += 1
if self._smS2 is __class__.SmS2.s2a:
self.setSmS2(__class__.SmS2.Null)
elif self._smS2 is __class__.SmS2.s2b:
self.setSmS2(__class__.SmS2.Null)
if self._deleted:
return
self.stopTimeouts2bTos1bHandler()
def setSmS2(self, aSmS2):
self._smS2 = aSmS2
self._smS2Visit += 1
visit = self._smS2Visit
if self._sm is not __class__.Sm.s2 and aSmS2 is not __class__.SmS2.Null:
self.setSm(__class__.Sm.s2)
if self._deleted or self._smS2Visit != visit:
return
if self._smS2 is __class__.SmS2.s2b:
self.startTimeouts2bTos1bHandler()
def startTimeouts1aTos1bHandler(self):
if self._deleted:
return
if self._timeouts1aTos1bHandler is not None:
self._timeouts1aTos1bHandler.stop()
visit = self._smS1Visit
delay = 2
if self._deleted or self._smS1Visit != visit:
return
self._timeouts1aTos1bHandler = __class__.TimedEventHandler(self, "timeouts1aTos1b", delay)
self._timeouts1aTos1bHandler.start()
def stopTimeouts1aTos1bHandler(self):
if self._timeouts1aTos1bHandler is not None:
self._timeouts1aTos1bHandler.stop()
def startTimeouts2bTos1bHandler(self):
if self._deleted:
return
if self._timeouts2bTos1bHandler is not None:
self._timeouts2bTos1bHandler.stop()
visit = self._smS2Visit
delay = 3
if self._deleted or self._smS2Visit != visit:
return
self._timeouts2bTos1bHandler = __class__.TimedEventHandler(self, "timeouts2bTos1b", delay)
self._timeouts2bTos1bHandler.start()
def stopTimeouts2bTos1bHandler(self):
if self._timeouts2bTos1bHandler is not None:
self._timeouts2bTos1bHandler.stop()
def delete(self):
self._deleted = True
self.stopTimeouts1aTos1bHandler()
self.stopTimeouts2bTos1bHandler()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
s0 = "s0"
s1 = "s1"
s2 = "s2"
s3 = "s3"
s4 = "s4"
def __str__(self):
return self.value
class TimedEventHandler:
def __init__(self, controller, timeoutMethodName, howLongInSeconds):
self._controller = controller
self._timeoutMethodName = timeoutMethodName
self._timer = threading.Timer(howLongInSeconds, self.run)
self._timer.daemon = False
def start(self):
self._timer.start()
def stop(self):
self._timer.cancel()
def isCurrent(self, handler, state, armedState):
return not self._timer.finished.is_set() and not self._controller._deleted and handler is self and state is armedState
def run(self):
controller = self._controller
if self._timeoutMethodName == "timeouts1Tos2":
if self.isCurrent(controller._timeouts1Tos2Handler, controller._sm, X.Sm.s1):
if not controller.timeouts1Tos2() and self.isCurrent(controller._timeouts1Tos2Handler, controller._sm, X.Sm.s1):
controller.startTimeouts1Tos2Handler()
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __init__(self):
self.__eventQueue = __class__.MessageQueue(None)
self._sm = None
self._smVisit = 0
self._timeouts1Tos2Handler = None
self._deleted = False
self.setSm(__class__.Sm.s0)
if self._deleted:
return
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
return answer
def getSm(self):
return self._sm
def _ev0(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s0:
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def ev0(self):
self.__eventQueue.put(self._ev0)
def _timeouts1Tos2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def timeouts1Tos2(self):
self.__eventQueue.put(self._timeouts1Tos2)
return True
def _ev2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self.setSm(__class__.Sm.s4)
wasEventProcessed = True
return wasEventProcessed
def ev2(self):
self.__eventQueue.put(self._ev2)
def _ev3(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s3:
self.setSm(__class__.Sm.s4)
wasEventProcessed = True
return wasEventProcessed
def ev3(self):
self.__eventQueue.put(self._ev3)
def exitSm(self):
self._smVisit += 1
if self._sm is __class__.Sm.s1:
self.stopTimeouts1Tos2Handler()
def setSm(self, aSm):
self._sm = aSm
self._smVisit += 1
if self._sm is __class__.Sm.s0:
self.a()
if self._deleted:
return
elif self._sm is __class__.Sm.s1:
self.startTimeouts1Tos2Handler()
def startTimeouts1Tos2Handler(self):
if self._deleted:
return
if self._timeouts1Tos2Handler is not None:
self._timeouts1Tos2Handler.stop()
visit = self._smVisit
delay = 2
if self._deleted or self._smVisit != visit:
return
self._timeouts1Tos2Handler = __class__.TimedEventHandler(self, "timeouts1Tos2", delay)
self._timeouts1Tos2Handler.start()
def stopTimeouts1Tos2Handler(self):
if self._timeouts1Tos2Handler is not None:
self._timeouts1Tos2Handler.stop()
def delete(self):
self._deleted = True
self.stopTimeouts1Tos2Handler()
self.__eventQueue.stop()
def a(self):
# line 19 "queuedStateMachine_timedTransition_1.ump"
System.out.println("a running");
# end line
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
s0 = "s0"
s1 = "s1"
s2 = "s2"
s3 = "s3"
s4 = "s4"
def __str__(self):
return self.value
class TimedEventHandler:
def __init__(self, controller, timeoutMethodName, howLongInSeconds):
self._controller = controller
self._timeoutMethodName = timeoutMethodName
self._timer = threading.Timer(howLongInSeconds, self.run)
self._timer.daemon = False
def start(self):
self._timer.start()
def stop(self):
self._timer.cancel()
def isCurrent(self, handler, state, armedState):
return not self._timer.finished.is_set() and not self._controller._deleted and handler is self and state is armedState
def run(self):
controller = self._controller
if self._timeoutMethodName == "timeouts1Tos2":
if self.isCurrent(controller._timeouts1Tos2Handler, controller._sm, X.Sm.s1):
if not controller.timeouts1Tos2() and self.isCurrent(controller._timeouts1Tos2Handler, controller._sm, X.Sm.s1):
controller.startTimeouts1Tos2Handler()
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __init__(self):
self.__eventQueue = __class__.MessageQueue(None)
self._sm = None
self._smVisit = 0
self._timeouts1Tos2Handler = None
self._deleted = False
self.setSm(__class__.Sm.s0)
if self._deleted:
return
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
return answer
def getSm(self):
return self._sm
def _ev0(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s0:
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def ev0(self):
self.__eventQueue.put(self._ev0)
def _timeouts1Tos2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def timeouts1Tos2(self):
self.__eventQueue.put(self._timeouts1Tos2)
return True
def _ev1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.s3)
wasEventProcessed = True
return wasEventProcessed
def ev1(self):
self.__eventQueue.put(self._ev1)
def _ev2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self.setSm(__class__.Sm.s4)
wasEventProcessed = True
return wasEventProcessed
def ev2(self):
self.__eventQueue.put(self._ev2)
def _ev3(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s3:
self.setSm(__class__.Sm.s4)
wasEventProcessed = True
return wasEventProcessed
def ev3(self):
self.__eventQueue.put(self._ev3)
def exitSm(self):
self._smVisit += 1
if self._sm is __class__.Sm.s1:
self.stopTimeouts1Tos2Handler()
def setSm(self, aSm):
self._sm = aSm
self._smVisit += 1
if self._sm is __class__.Sm.s0:
self.a()
if self._deleted:
return
elif self._sm is __class__.Sm.s1:
self.startTimeouts1Tos2Handler()
def startTimeouts1Tos2Handler(self):
if self._deleted:
return
if self._timeouts1Tos2Handler is not None:
self._timeouts1Tos2Handler.stop()
visit = self._smVisit
delay = 2
if self._deleted or self._smVisit != visit:
return
self._timeouts1Tos2Handler = __class__.TimedEventHandler(self, "timeouts1Tos2", delay)
self._timeouts1Tos2Handler.start()
def stopTimeouts1Tos2Handler(self):
if self._timeouts1Tos2Handler is not None:
self._timeouts1Tos2Handler.stop()
def delete(self):
self._deleted = True
self.stopTimeouts1Tos2Handler()
self.__eventQueue.stop()
def a(self):
# line 20 "queuedStateMachine_timedTransition_2.ump"
System.out.println("a running");
# end line
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class PooledSMwithUnspecifiedReception:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
error1 = "error1"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __canProcess(self, call):
name = call.__name__
return (self._sm is __class__.Sm.s1 and name in ("_e1", "_unspecified",))
def __init__(self):
self.__eventQueue = __class__.MessageQueue(self.__canProcess)
self._sm = None
self._deleted = False
self.setSm(__class__.Sm.s1)
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
return answer
def getSm(self):
return self._sm
def _e1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def e1(self):
self.__eventQueue.put(self._e1)
def _unspecified(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.setSm(__class__.Sm.error1)
wasEventProcessed = True
return wasEventProcessed
def unspecified(self):
self.__eventQueue.put(self._unspecified)
def __autotransition1__(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.error1:
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def setSm(self, aSm):
self._sm = aSm
if self._sm is __class__.Sm.error1:
self.__autotransition1__()
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class X:
class Sm(Enum):
s0 = "s0"
s1 = "s1"
def __str__(self):
return self.value
class SmS0T1(Enum):
Null = "Null"
t1 = "t1"
def __str__(self):
return self.value
class SmS0T2(Enum):
Null = "Null"
t2 = "t2"
t3 = "t3"
def __str__(self):
return self.value
class SmS1T1(Enum):
Null = "Null"
t1 = "t1"
t4 = "t4"
def __str__(self):
return self.value
class SmS1T2(Enum):
Null = "Null"
t2 = "t2"
t5 = "t5"
def __str__(self):
return self.value
def __init__(self):
self._sm = None
self._smVisit = 0
self._smS0T1 = None
self._smS0T2 = None
self._smS1T1 = None
self._smS1T2 = None
self._deleted = False
self.setSmS0T1(__class__.SmS0T1.Null)
self.setSmS0T2(__class__.SmS0T2.Null)
self.setSmS1T1(__class__.SmS1T1.Null)
self.setSmS1T2(__class__.SmS1T2.Null)
self.setSm(__class__.Sm.s0)
def getSmFullName(self):
answer = str(self._sm)
if self._smS0T1 is not __class__.SmS0T1.Null:
answer += "." + str(self._smS0T1)
if self._smS0T2 is not __class__.SmS0T2.Null:
answer += "." + str(self._smS0T2)
if self._smS1T1 is not __class__.SmS1T1.Null:
answer += "." + str(self._smS1T1)
if self._smS1T2 is not __class__.SmS1T2.Null:
answer += "." + str(self._smS1T2)
return answer
def getSm(self):
return self._sm
def getSmS0T1(self):
return self._smS0T1
def getSmS0T2(self):
return self._smS0T2
def getSmS1T1(self):
return self._smS1T1
def getSmS1T2(self):
return self._smS1T2
def goS1(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS0T1 = self._smS0T1
if aSmS0T1 is __class__.SmS0T1.t1:
self.exitSm()
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def goT3(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS0T2 = self._smS0T2
if aSmS0T2 is __class__.SmS0T2.t2:
self.exitSmS0T2()
self.setSmS0T2(__class__.SmS0T2.t3)
wasEventProcessed = True
return wasEventProcessed
def goT4(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1T1 = self._smS1T1
if aSmS1T1 is __class__.SmS1T1.t1:
self.exitSmS1T1()
self.setSmS1T1(__class__.SmS1T1.t4)
wasEventProcessed = True
return wasEventProcessed
def goT5(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1T2 = self._smS1T2
if aSmS1T2 is __class__.SmS1T2.t2:
self.exitSmS1T2()
self.setSmS1T2(__class__.SmS1T2.t5)
wasEventProcessed = True
return wasEventProcessed
def exitSm(self):
self._smVisit += 1
if self._sm is __class__.Sm.s0:
self.exitSmS0T1()
self.exitSmS0T2()
elif self._sm is __class__.Sm.s1:
self.exitSmS1T1()
self.exitSmS1T2()
def setSm(self, aSm):
self._sm = aSm
self._smVisit += 1
visit = self._smVisit
if self._sm is __class__.Sm.s0:
if self._smS0T1 is __class__.SmS0T1.Null:
self.setSmS0T1(__class__.SmS0T1.t1)
if self._smVisit != visit:
return
if self._smS0T2 is __class__.SmS0T2.Null:
self.setSmS0T2(__class__.SmS0T2.t2)
elif self._sm is __class__.Sm.s1:
if self._smS1T1 is __class__.SmS1T1.Null:
self.setSmS1T1(__class__.SmS1T1.t1)
if self._smVisit != visit:
return
if self._smS1T2 is __class__.SmS1T2.Null:
self.setSmS1T2(__class__.SmS1T2.t2)
def exitSmS0T1(self):
if self._smS0T1 is __class__.SmS0T1.t1:
self.setSmS0T1(__class__.SmS0T1.Null)
def setSmS0T1(self, aSmS0T1):
self._smS0T1 = aSmS0T1
if self._sm is not __class__.Sm.s0 and aSmS0T1 is not __class__.SmS0T1.Null:
self.setSm(__class__.Sm.s0)
def exitSmS0T2(self):
if self._smS0T2 is __class__.SmS0T2.t2:
self.setSmS0T2(__class__.SmS0T2.Null)
elif self._smS0T2 is __class__.SmS0T2.t3:
self.setSmS0T2(__class__.SmS0T2.Null)
def setSmS0T2(self, aSmS0T2):
self._smS0T2 = aSmS0T2
if self._sm is not __class__.Sm.s0 and aSmS0T2 is not __class__.SmS0T2.Null:
self.setSm(__class__.Sm.s0)
def exitSmS1T1(self):
if self._smS1T1 is __class__.SmS1T1.t1:
self.setSmS1T1(__class__.SmS1T1.Null)
elif self._smS1T1 is __class__.SmS1T1.t4:
self.setSmS1T1(__class__.SmS1T1.Null)
def setSmS1T1(self, aSmS1T1):
self._smS1T1 = aSmS1T1
if self._sm is not __class__.Sm.s1 and aSmS1T1 is not __class__.SmS1T1.Null:
self.setSm(__class__.Sm.s1)
def exitSmS1T2(self):
if self._smS1T2 is __class__.SmS1T2.t2:
self.setSmS1T2(__class__.SmS1T2.Null)
elif self._smS1T2 is __class__.SmS1T2.t5:
self.setSmS1T2(__class__.SmS1T2.Null)
def setSmS1T2(self, aSmS1T2):
self._smS1T2 = aSmS1T2
if self._sm is not __class__.Sm.s1 and aSmS1T2 is not __class__.SmS1T2.Null:
self.setSm(__class__.Sm.s1)
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Light:
class Bulb(Enum):
Off = "Off"
On = "On"
def __str__(self):
return self.value
def __init__(self):
self._bulb = None
self._deleted = False
self.setBulb(__class__.Bulb.Off)
def getBulbFullName(self):
answer = str(self._bulb)
return answer
def getBulb(self):
return self._bulb
def flip(self):
if self._deleted:
return False
wasEventProcessed = False
aBulb = self._bulb
if aBulb is __class__.Bulb.Off:
self.setBulb(__class__.Bulb.On)
wasEventProcessed = True
elif aBulb is __class__.Bulb.On:
self.setBulb(__class__.Bulb.Off)
wasEventProcessed = True
return wasEventProcessed
def setBulb(self, aBulb):
self._bulb = aBulb
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class stateMachineWithNegativeNumberGuard:
class Status(Enum):
on = "on"
off = "off"
def __str__(self):
return self.value
def __init__(self):
self._status = None
self._deleted = False
self.setStatus(__class__.Status.on)
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def turnOff(self, pn):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.on:
if pn > -1:
self.setStatus(__class__.Status.off)
wasEventProcessed = True
return wasEventProcessed
def turnOn(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.off:
self.setStatus(__class__.Status.on)
wasEventProcessed = True
return wasEventProcessed
def setStatus(self, aStatus):
self._status = aStatus
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
def __str__(self):
return self.value
class SmS1(Enum):
Null = "Null"
s1a = "s1a"
s1b = "s1b"
def __str__(self):
return self.value
class Sm1(Enum):
s3 = "s3"
s4 = "s4"
def __str__(self):
return self.value
class Sm1S4(Enum):
Null = "Null"
s4a = "s4a"
s4b = "s4b"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __init__(self):
self.__eventQueue = __class__.MessageQueue(None)
self._sm = None
self._smS1 = None
self._sm1 = None
self._sm1S4 = None
self._deleted = False
self.setSmS1(__class__.SmS1.Null)
self.setSm(__class__.Sm.s1)
self.setSm1S4(__class__.Sm1S4.Null)
self.setSm1(__class__.Sm1.s3)
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
if self._smS1 is not __class__.SmS1.Null:
answer += "." + str(self._smS1)
return answer
def getSm1FullName(self):
answer = str(self._sm1)
if self._sm1S4 is not __class__.Sm1S4.Null:
answer += "." + str(self._sm1S4)
return answer
def getSm(self):
return self._sm
def getSm1(self):
return self._sm1
def getSmS1(self):
return self._smS1
def getSm1S4(self):
return self._sm1S4
def _e1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.exitSmS1()
self.setSmS1(__class__.SmS1.s1a)
wasEventProcessed = True
return wasEventProcessed
def e1(self):
self.__eventQueue.put(self._e1)
def _e2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def e2(self):
self.__eventQueue.put(self._e2)
def _e3(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1 = self._sm1
if aSm1 is __class__.Sm1.s3:
self.setSm1(__class__.Sm1.s4)
wasEventProcessed = True
return wasEventProcessed
def e3(self):
self.__eventQueue.put(self._e3)
def _e4(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1 = self._sm1
if aSm1 is __class__.Sm1.s4:
self.exitSm1S4()
self.setSm1S4(__class__.Sm1S4.s4a)
wasEventProcessed = True
return wasEventProcessed
def e4(self):
self.__eventQueue.put(self._e4)
def _e5(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s1a:
self.exitSmS1()
self.setSmS1(__class__.SmS1.s1b)
wasEventProcessed = True
return wasEventProcessed
def e5(self):
self.__eventQueue.put(self._e5)
def _e6(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s1b:
self.exitSm()
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def e6(self):
self.__eventQueue.put(self._e6)
def _e7(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1S4 = self._sm1S4
if aSm1S4 is __class__.Sm1S4.s4a:
self.exitSm1S4()
self.setSm1S4(__class__.Sm1S4.s4b)
wasEventProcessed = True
return wasEventProcessed
def e7(self):
self.__eventQueue.put(self._e7)
def _e8(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1S4 = self._sm1S4
if aSm1S4 is __class__.Sm1S4.s4b:
self.exitSm1()
self.setSm1(__class__.Sm1.s3)
wasEventProcessed = True
return wasEventProcessed
def e8(self):
self.__eventQueue.put(self._e8)
def exitSm(self):
if self._sm is __class__.Sm.s1:
self.exitSmS1()
def setSm(self, aSm):
self._sm = aSm
if self._sm is __class__.Sm.s1:
if self._smS1 is __class__.SmS1.Null:
self.setSmS1(__class__.SmS1.s1a)
def exitSm1(self):
if self._sm1 is __class__.Sm1.s4:
self.exitSm1S4()
def setSm1(self, aSm1):
self._sm1 = aSm1
if self._sm1 is __class__.Sm1.s4:
if self._sm1S4 is __class__.Sm1S4.Null:
self.setSm1S4(__class__.Sm1S4.s4a)
def exitSmS1(self):
if self._smS1 is __class__.SmS1.s1a:
self.setSmS1(__class__.SmS1.Null)
elif self._smS1 is __class__.SmS1.s1b:
self.setSmS1(__class__.SmS1.Null)
def setSmS1(self, aSmS1):
self._smS1 = aSmS1
if self._sm is not __class__.Sm.s1 and aSmS1 is not __class__.SmS1.Null:
self.setSm(__class__.Sm.s1)
def exitSm1S4(self):
if self._sm1S4 is __class__.Sm1S4.s4a:
self.setSm1S4(__class__.Sm1S4.Null)
elif self._sm1S4 is __class__.Sm1S4.s4b:
self.setSm1S4(__class__.Sm1S4.Null)
def setSm1S4(self, aSm1S4):
self._sm1S4 = aSm1S4
if self._sm1 is not __class__.Sm1.s4 and aSm1S4 is not __class__.Sm1S4.Null:
self.setSm1(__class__.Sm1.s4)
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
s3 = "s3"
def __str__(self):
return self.value
class TimedEventHandler:
def __init__(self, controller, timeoutMethodName, howLongInSeconds):
self._controller = controller
self._timeoutMethodName = timeoutMethodName
self._timer = threading.Timer(howLongInSeconds, self.run)
self._timer.daemon = False
def start(self):
self._timer.start()
def stop(self):
self._timer.cancel()
def isCurrent(self, handler, state, armedState):
return not self._timer.finished.is_set() and not self._controller._deleted and handler is self and state is armedState
def run(self):
controller = self._controller
if self._timeoutMethodName == "timeouts2Tos3":
if self.isCurrent(controller._timeouts2Tos3Handler, controller._sm, X.Sm.s2):
if not controller.timeouts2Tos3() and self.isCurrent(controller._timeouts2Tos3Handler, controller._sm, X.Sm.s2):
controller.startTimeouts2Tos3Handler()
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __init__(self):
self.__eventQueue = __class__.MessageQueue(None)
self._sm = None
self._smVisit = 0
self._timeouts2Tos3Handler = None
self._deleted = False
self.setSm(__class__.Sm.s1)
if self._deleted:
return
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
return answer
def getSm(self):
return self._sm
def __autotransition1__(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.setSm(__class__.Sm.s3)
wasEventProcessed = True
return wasEventProcessed
def _timeouts2Tos3(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.s3)
wasEventProcessed = True
return wasEventProcessed
def timeouts2Tos3(self):
self.__eventQueue.put(self._timeouts2Tos3)
return True
def exitSm(self):
self._smVisit += 1
if self._sm is __class__.Sm.s2:
self.stopTimeouts2Tos3Handler()
def setSm(self, aSm):
self._sm = aSm
self._smVisit += 1
if self._sm is __class__.Sm.s1:
self.__autotransition1__()
elif self._sm is __class__.Sm.s2:
self.startTimeouts2Tos3Handler()
def startTimeouts2Tos3Handler(self):
if self._deleted:
return
if self._timeouts2Tos3Handler is not None:
self._timeouts2Tos3Handler.stop()
visit = self._smVisit
delay = 10
if self._deleted or self._smVisit != visit:
return
self._timeouts2Tos3Handler = __class__.TimedEventHandler(self, "timeouts2Tos3", delay)
self._timeouts2Tos3Handler.start()
def stopTimeouts2Tos3Handler(self):
if self._timeouts2Tos3Handler is not None:
self._timeouts2Tos3Handler.stop()
def delete(self):
self._deleted = True
self.stopTimeouts2Tos3Handler()
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
s0 = "s0"
s1 = "s1"
s2 = "s2"
s3 = "s3"
s4 = "s4"
def __str__(self):
return self.value
class TimedEventHandler:
def __init__(self, controller, timeoutMethodName, howLongInSeconds):
self._controller = controller
self._timeoutMethodName = timeoutMethodName
self._timer = threading.Timer(howLongInSeconds, self.run)
self._timer.daemon = False
def start(self):
self._timer.start()
def stop(self):
self._timer.cancel()
def isCurrent(self, handler, state, armedState):
return not self._timer.finished.is_set() and not self._controller._deleted and handler is self and state is armedState
def run(self):
controller = self._controller
if self._timeoutMethodName == "timeouts1Tos2":
if self.isCurrent(controller._timeouts1Tos2Handler, controller._sm, X.Sm.s1):
if not controller.timeouts1Tos2() and self.isCurrent(controller._timeouts1Tos2Handler, controller._sm, X.Sm.s1):
controller.startTimeouts1Tos2Handler()
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __canProcess(self, call):
name = call.__name__
return (self._sm is __class__.Sm.s0 and name in ("_ev0",)
or self._sm is __class__.Sm.s1 and name in ("_timeouts1Tos2",)
or self._sm is __class__.Sm.s2 and name in ("_ev2",)
or self._sm is __class__.Sm.s3 and name in ("_ev3",))
def __init__(self):
self.__eventQueue = __class__.MessageQueue(self.__canProcess)
self._sm = None
self._smVisit = 0
self._timeouts1Tos2Handler = None
self._deleted = False
self.setSm(__class__.Sm.s0)
if self._deleted:
return
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
return answer
def getSm(self):
return self._sm
def _ev0(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s0:
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def ev0(self):
self.__eventQueue.put(self._ev0)
def _timeouts1Tos2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def timeouts1Tos2(self):
self.__eventQueue.put(self._timeouts1Tos2)
return True
def _ev2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self.setSm(__class__.Sm.s4)
wasEventProcessed = True
return wasEventProcessed
def ev2(self):
self.__eventQueue.put(self._ev2)
def _ev3(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s3:
self.setSm(__class__.Sm.s4)
wasEventProcessed = True
return wasEventProcessed
def ev3(self):
self.__eventQueue.put(self._ev3)
def exitSm(self):
self._smVisit += 1
if self._sm is __class__.Sm.s1:
self.stopTimeouts1Tos2Handler()
def setSm(self, aSm):
self._sm = aSm
self._smVisit += 1
if self._sm is __class__.Sm.s0:
self.a()
if self._deleted:
return
elif self._sm is __class__.Sm.s1:
self.startTimeouts1Tos2Handler()
def startTimeouts1Tos2Handler(self):
if self._deleted:
return
if self._timeouts1Tos2Handler is not None:
self._timeouts1Tos2Handler.stop()
visit = self._smVisit
delay = 2
if self._deleted or self._smVisit != visit:
return
self._timeouts1Tos2Handler = __class__.TimedEventHandler(self, "timeouts1Tos2", delay)
self._timeouts1Tos2Handler.start()
def stopTimeouts1Tos2Handler(self):
if self._timeouts1Tos2Handler is not None:
self._timeouts1Tos2Handler.stop()
def delete(self):
self._deleted = True
self.stopTimeouts1Tos2Handler()
self.__eventQueue.stop()
def a(self):
# line 19 "pooledStateMachine_timedTransition_1.ump"
System.out.println("a running");
# end line
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
s0 = "s0"
s1 = "s1"
s2 = "s2"
s3 = "s3"
s4 = "s4"
def __str__(self):
return self.value
class TimedEventHandler:
def __init__(self, controller, timeoutMethodName, howLongInSeconds):
self._controller = controller
self._timeoutMethodName = timeoutMethodName
self._timer = threading.Timer(howLongInSeconds, self.run)
self._timer.daemon = False
def start(self):
self._timer.start()
def stop(self):
self._timer.cancel()
def isCurrent(self, handler, state, armedState):
return not self._timer.finished.is_set() and not self._controller._deleted and handler is self and state is armedState
def run(self):
controller = self._controller
if self._timeoutMethodName == "timeouts1Tos2":
if self.isCurrent(controller._timeouts1Tos2Handler, controller._sm, X.Sm.s1):
if not controller.timeouts1Tos2() and self.isCurrent(controller._timeouts1Tos2Handler, controller._sm, X.Sm.s1):
controller.startTimeouts1Tos2Handler()
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __canProcess(self, call):
name = call.__name__
return (self._sm is __class__.Sm.s0 and name in ("_ev0",)
or self._sm is __class__.Sm.s1 and name in ("_timeouts1Tos2", "_ev1",)
or self._sm is __class__.Sm.s2 and name in ("_ev2",)
or self._sm is __class__.Sm.s3 and name in ("_ev3",))
def __init__(self):
self.__eventQueue = __class__.MessageQueue(self.__canProcess)
self._sm = None
self._smVisit = 0
self._timeouts1Tos2Handler = None
self._deleted = False
self.setSm(__class__.Sm.s0)
if self._deleted:
return
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
return answer
def getSm(self):
return self._sm
def _ev0(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s0:
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def ev0(self):
self.__eventQueue.put(self._ev0)
def _timeouts1Tos2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def timeouts1Tos2(self):
self.__eventQueue.put(self._timeouts1Tos2)
return True
def _ev1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.s3)
wasEventProcessed = True
return wasEventProcessed
def ev1(self):
self.__eventQueue.put(self._ev1)
def _ev2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self.setSm(__class__.Sm.s4)
wasEventProcessed = True
return wasEventProcessed
def ev2(self):
self.__eventQueue.put(self._ev2)
def _ev3(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s3:
self.setSm(__class__.Sm.s4)
wasEventProcessed = True
return wasEventProcessed
def ev3(self):
self.__eventQueue.put(self._ev3)
def exitSm(self):
self._smVisit += 1
if self._sm is __class__.Sm.s1:
self.stopTimeouts1Tos2Handler()
def setSm(self, aSm):
self._sm = aSm
self._smVisit += 1
if self._sm is __class__.Sm.s0:
self.a()
if self._deleted:
return
elif self._sm is __class__.Sm.s1:
self.startTimeouts1Tos2Handler()
def startTimeouts1Tos2Handler(self):
if self._deleted:
return
if self._timeouts1Tos2Handler is not None:
self._timeouts1Tos2Handler.stop()
visit = self._smVisit
delay = 2
if self._deleted or self._smVisit != visit:
return
self._timeouts1Tos2Handler = __class__.TimedEventHandler(self, "timeouts1Tos2", delay)
self._timeouts1Tos2Handler.start()
def stopTimeouts1Tos2Handler(self):
if self._timeouts1Tos2Handler is not None:
self._timeouts1Tos2Handler.stop()
def delete(self):
self._deleted = True
self.stopTimeouts1Tos2Handler()
self.__eventQueue.stop()
def a(self):
# line 20 "pooledStateMachine_timedTransition_2.ump"
System.out.println("a running");
# end line
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class Mentor:
class Status(Enum):
Ok = "Ok"
NotOk = "NotOk"
def __str__(self):
return self.value
class TimedEventHandler:
def __init__(self, controller, timeoutMethodName, howLongInSeconds):
self._controller = controller
self._timeoutMethodName = timeoutMethodName
self._timer = threading.Timer(howLongInSeconds, self.run)
self._timer.daemon = False
def start(self):
self._timer.start()
def stop(self):
self._timer.cancel()
def isCurrent(self, handler, state, armedState):
return not self._timer.finished.is_set() and not self._controller._deleted and handler is self and state is armedState
def run(self):
controller = self._controller
if self._timeoutMethodName == "timeoutOkToNotOk":
if self.isCurrent(controller._timeoutOkToNotOkHandler, controller._status, Mentor.Status.Ok):
if not controller.timeoutOkToNotOk() and self.isCurrent(controller._timeoutOkToNotOkHandler, controller._status, Mentor.Status.Ok):
controller.startTimeoutOkToNotOkHandler()
elif self._timeoutMethodName == "timeoutNotOkToOk":
if self.isCurrent(controller._timeoutNotOkToOkHandler, controller._status, Mentor.Status.NotOk):
if not controller.timeoutNotOkToOk() and self.isCurrent(controller._timeoutNotOkToOkHandler, controller._status, Mentor.Status.NotOk):
controller.startTimeoutNotOkToOkHandler()
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __init__(self):
self._howLongUntilOk = 3
self.__eventQueue = __class__.MessageQueue(None)
self._status = None
self._statusVisit = 0
self._timeoutOkToNotOkHandler = None
self._timeoutNotOkToOkHandler = None
self._deleted = False
self.setStatus(__class__.Status.Ok)
if self._deleted:
return
self.__eventQueue.start()
def setHowLongUntilOk(self, aHowLongUntilOk):
self._howLongUntilOk = aHowLongUntilOk
return True
def getHowLongUntilOk(self):
return self._howLongUntilOk
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def _timeoutOkToNotOk(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Ok:
self.exitStatus()
if self._deleted:
return True
self.setStatus(__class__.Status.NotOk)
wasEventProcessed = True
return wasEventProcessed
def timeoutOkToNotOk(self):
self.__eventQueue.put(self._timeoutOkToNotOk)
return True
def _timeoutNotOkToOk(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.NotOk:
self.exitStatus()
if self._deleted:
return True
self.setStatus(__class__.Status.Ok)
wasEventProcessed = True
return wasEventProcessed
def timeoutNotOkToOk(self):
self.__eventQueue.put(self._timeoutNotOkToOk)
return True
def exitStatus(self):
self._statusVisit += 1
if self._status is __class__.Status.Ok:
self.stopTimeoutOkToNotOkHandler()
elif self._status is __class__.Status.NotOk:
self.stopTimeoutNotOkToOkHandler()
def setStatus(self, aStatus):
self._status = aStatus
self._statusVisit += 1
if self._status is __class__.Status.Ok:
self.startTimeoutOkToNotOkHandler()
elif self._status is __class__.Status.NotOk:
self.startTimeoutNotOkToOkHandler()
def startTimeoutOkToNotOkHandler(self):
if self._deleted:
return
if self._timeoutOkToNotOkHandler is not None:
self._timeoutOkToNotOkHandler.stop()
visit = self._statusVisit
delay = 4
if self._deleted or self._statusVisit != visit:
return
self._timeoutOkToNotOkHandler = __class__.TimedEventHandler(self, "timeoutOkToNotOk", delay)
self._timeoutOkToNotOkHandler.start()
def stopTimeoutOkToNotOkHandler(self):
if self._timeoutOkToNotOkHandler is not None:
self._timeoutOkToNotOkHandler.stop()
def startTimeoutNotOkToOkHandler(self):
if self._deleted:
return
if self._timeoutNotOkToOkHandler is not None:
self._timeoutNotOkToOkHandler.stop()
visit = self._statusVisit
delay = self._howLongUntilOk
if self._deleted or self._statusVisit != visit:
return
self._timeoutNotOkToOkHandler = __class__.TimedEventHandler(self, "timeoutNotOkToOk", delay)
self._timeoutNotOkToOkHandler.start()
def stopTimeoutNotOkToOkHandler(self):
if self._timeoutNotOkToOkHandler is not None:
self._timeoutNotOkToOkHandler.stop()
def delete(self):
self._deleted = True
self.stopTimeoutOkToNotOkHandler()
self.stopTimeoutNotOkToOkHandler()
self.__eventQueue.stop()
def __str__(self):
return (super().__str__() + "["
+ "howLongUntilOk:" + str(self.getHowLongUntilOk())
+ "]")
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Course:
class Status(Enum):
Open = "Open"
Full = "Full"
def __str__(self):
return self.value
def __init__(self):
self._status = None
self._deleted = False
self.setStatus(__class__.Status.Open)
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def register(self, name, age, grades):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Open:
self.setStatus(__class__.Status.Open)
wasEventProcessed = True
return wasEventProcessed
def reject(self, firstName):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Full:
self.setStatus(__class__.Status.Full)
wasEventProcessed = True
return wasEventProcessed
def setStatus(self, aStatus):
self._status = aStatus
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
def __str__(self):
return self.value
class SmS1(Enum):
Null = "Null"
s1a = "s1a"
s1b = "s1b"
def __str__(self):
return self.value
class Sm1(Enum):
s3 = "s3"
s4 = "s4"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __init__(self):
self.__eventQueue = __class__.MessageQueue(None)
self._sm = None
self._smS1 = None
self._sm1 = None
self._deleted = False
self.setSmS1(__class__.SmS1.Null)
self.setSm(__class__.Sm.s1)
self.setSm1(__class__.Sm1.s3)
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
if self._smS1 is not __class__.SmS1.Null:
answer += "." + str(self._smS1)
return answer
def getSm1FullName(self):
answer = str(self._sm1)
return answer
def getSm(self):
return self._sm
def getSm1(self):
return self._sm1
def getSmS1(self):
return self._smS1
def _e1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.exitSmS1()
self.setSmS1(__class__.SmS1.s1a)
wasEventProcessed = True
return wasEventProcessed
def e1(self):
self.__eventQueue.put(self._e1)
def _e2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def e2(self):
self.__eventQueue.put(self._e2)
def _e3(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1 = self._sm1
if aSm1 is __class__.Sm1.s3:
self.setSm1(__class__.Sm1.s4)
wasEventProcessed = True
return wasEventProcessed
def e3(self):
self.__eventQueue.put(self._e3)
def _e4(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1 = self._sm1
if aSm1 is __class__.Sm1.s4:
self.setSm1(__class__.Sm1.s3)
wasEventProcessed = True
return wasEventProcessed
def e4(self):
self.__eventQueue.put(self._e4)
def _e5(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s1a:
self.exitSmS1()
self.setSmS1(__class__.SmS1.s1b)
wasEventProcessed = True
return wasEventProcessed
def e5(self):
self.__eventQueue.put(self._e5)
def _e6(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s1b:
self.exitSm()
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def e6(self):
self.__eventQueue.put(self._e6)
def exitSm(self):
if self._sm is __class__.Sm.s1:
self.exitSmS1()
def setSm(self, aSm):
self._sm = aSm
if self._sm is __class__.Sm.s1:
if self._smS1 is __class__.SmS1.Null:
self.setSmS1(__class__.SmS1.s1a)
def setSm1(self, aSm1):
self._sm1 = aSm1
def exitSmS1(self):
if self._smS1 is __class__.SmS1.s1a:
self.setSmS1(__class__.SmS1.Null)
elif self._smS1 is __class__.SmS1.s1b:
self.setSmS1(__class__.SmS1.Null)
def setSmS1(self, aSmS1):
self._smS1 = aSmS1
if self._sm is not __class__.Sm.s1 and aSmS1 is not __class__.SmS1.Null:
self.setSm(__class__.Sm.s1)
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Mentor:
class Status(Enum):
def __str__(self):
return self.value
def __init__(self):
self._status = None
self._deleted = False
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
q = "q"
s = "s"
def __str__(self):
return self.value
class Sm1(Enum):
s1 = "s1"
s2 = "s2"
def __str__(self):
return self.value
class Sm1S1(Enum):
Null = "Null"
s1a = "s1a"
s1b = "s1b"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __canProcess(self, call):
name = call.__name__
return (self._sm1 is __class__.Sm1.s1 and name in ("_e1",)
or self._sm1 is __class__.Sm1.s2 and name in ("_e2",)
or self._sm1S1 is __class__.Sm1S1.s1a and name in ("_e5",)
or self._sm1S1 is __class__.Sm1S1.s1b and name in ("_e6",))
def __init__(self):
self.__eventQueue = __class__.MessageQueue(self.__canProcess)
self._sm = None
self._sm1 = None
self._sm1S1 = None
self._deleted = False
self.setSm(__class__.Sm.q)
self.setSm1S1(__class__.Sm1S1.Null)
self.setSm1(__class__.Sm1.s1)
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
return answer
def getSm1FullName(self):
answer = str(self._sm1)
if self._sm1S1 is not __class__.Sm1S1.Null:
answer += "." + str(self._sm1S1)
return answer
def getSm(self):
return self._sm
def getSm1(self):
return self._sm1
def getSm1S1(self):
return self._sm1S1
def _e1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1 = self._sm1
if aSm1 is __class__.Sm1.s1:
self.exitSm1S1()
self.setSm1S1(__class__.Sm1S1.s1a)
wasEventProcessed = True
return wasEventProcessed
def e1(self):
self.__eventQueue.put(self._e1)
def _e2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1 = self._sm1
if aSm1 is __class__.Sm1.s2:
self.setSm1(__class__.Sm1.s1)
wasEventProcessed = True
return wasEventProcessed
def e2(self):
self.__eventQueue.put(self._e2)
def _e5(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1S1 = self._sm1S1
if aSm1S1 is __class__.Sm1S1.s1a:
self.exitSm1S1()
self.setSm1S1(__class__.Sm1S1.s1b)
wasEventProcessed = True
return wasEventProcessed
def e5(self):
self.__eventQueue.put(self._e5)
def _e6(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1S1 = self._sm1S1
if aSm1S1 is __class__.Sm1S1.s1b:
self.exitSm1()
self.setSm1(__class__.Sm1.s2)
wasEventProcessed = True
return wasEventProcessed
def e6(self):
self.__eventQueue.put(self._e6)
def setSm(self, aSm):
self._sm = aSm
return True
def exitSm1(self):
if self._sm1 is __class__.Sm1.s1:
self.exitSm1S1()
def setSm1(self, aSm1):
self._sm1 = aSm1
if self._sm1 is __class__.Sm1.s1:
if self._sm1S1 is __class__.Sm1S1.Null:
self.setSm1S1(__class__.Sm1S1.s1a)
def exitSm1S1(self):
if self._sm1S1 is __class__.Sm1S1.s1a:
self.setSm1S1(__class__.Sm1S1.Null)
elif self._sm1S1 is __class__.Sm1S1.s1b:
self.setSm1S1(__class__.Sm1S1.Null)
def setSm1S1(self, aSm1S1):
self._sm1S1 = aSm1S1
if self._sm1 is not __class__.Sm1.s1 and aSm1S1 is not __class__.Sm1S1.Null:
self.setSm1(__class__.Sm1.s1)
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
def __str__(self):
return self.value
class SmS1(Enum):
Null = "Null"
s1a = "s1a"
s1b = "s1b"
def __str__(self):
return self.value
class TimedEventHandler:
def __init__(self, controller, timeoutMethodName, howLongInSeconds):
self._controller = controller
self._timeoutMethodName = timeoutMethodName
self._timer = threading.Timer(howLongInSeconds, self.run)
self._timer.daemon = False
def start(self):
self._timer.start()
def stop(self):
self._timer.cancel()
def isCurrent(self, handler, state, armedState):
return not self._timer.finished.is_set() and not self._controller._deleted and handler is self and state is armedState
def run(self):
controller = self._controller
if self._timeoutMethodName == "timeouts1aTos1b":
if self.isCurrent(controller._timeouts1aTos1bHandler, controller._smS1, X.SmS1.s1a):
if not controller.timeouts1aTos1b() and self.isCurrent(controller._timeouts1aTos1bHandler, controller._smS1, X.SmS1.s1a):
controller.startTimeouts1aTos1bHandler()
def __init__(self):
self._sm = None
self._smS1 = None
self._smS1Visit = 0
self._timeouts1aTos1bHandler = None
self._deleted = False
self.setSmS1(__class__.SmS1.Null)
if self._deleted:
return
self.setSm(__class__.Sm.s1)
if self._deleted:
return
def getSmFullName(self):
answer = str(self._sm)
if self._smS1 is not __class__.SmS1.Null:
answer += "." + str(self._smS1)
return answer
def getSm(self):
return self._sm
def getSmS1(self):
return self._smS1
def e2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def timeouts1aTos1b(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s1a:
self.exitSmS1()
if self._deleted:
return True
self.setSmS1(__class__.SmS1.s1b)
wasEventProcessed = True
return wasEventProcessed
def e1(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s1b:
self.exitSm()
if self._deleted:
return True
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def exitSm(self):
if self._sm is __class__.Sm.s1:
self.exitSmS1()
def setSm(self, aSm):
self._sm = aSm
if self._sm is __class__.Sm.s1:
if self._smS1 is __class__.SmS1.Null:
self.setSmS1(__class__.SmS1.s1a)
def exitSmS1(self):
self._smS1Visit += 1
if self._smS1 is __class__.SmS1.s1a:
self.setSmS1(__class__.SmS1.Null)
if self._deleted:
return
self.stopTimeouts1aTos1bHandler()
elif self._smS1 is __class__.SmS1.s1b:
self.setSmS1(__class__.SmS1.Null)
def setSmS1(self, aSmS1):
self._smS1 = aSmS1
self._smS1Visit += 1
visit = self._smS1Visit
if self._sm is not __class__.Sm.s1 and aSmS1 is not __class__.SmS1.Null:
self.setSm(__class__.Sm.s1)
if self._deleted or self._smS1Visit != visit:
return
if self._smS1 is __class__.SmS1.s1a:
self.startTimeouts1aTos1bHandler()
def startTimeouts1aTos1bHandler(self):
if self._deleted:
return
if self._timeouts1aTos1bHandler is not None:
self._timeouts1aTos1bHandler.stop()
visit = self._smS1Visit
delay = 2
if self._deleted or self._smS1Visit != visit:
return
self._timeouts1aTos1bHandler = __class__.TimedEventHandler(self, "timeouts1aTos1b", delay)
self._timeouts1aTos1bHandler.start()
def stopTimeouts1aTos1bHandler(self):
if self._timeouts1aTos1bHandler is not None:
self._timeouts1aTos1bHandler.stop()
def delete(self):
self._deleted = True
self.stopTimeouts1aTos1bHandler()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
q = "q"
s = "s"
def __str__(self):
return self.value
class Sm1(Enum):
s1 = "s1"
s2 = "s2"
def __str__(self):
return self.value
class Sm1S1(Enum):
Null = "Null"
s1a = "s1a"
s1b = "s1b"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __init__(self):
self.__eventQueue = __class__.MessageQueue(None)
self._sm = None
self._sm1 = None
self._sm1S1 = None
self._deleted = False
self.setSm(__class__.Sm.q)
self.setSm1S1(__class__.Sm1S1.Null)
self.setSm1(__class__.Sm1.s1)
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
return answer
def getSm1FullName(self):
answer = str(self._sm1)
if self._sm1S1 is not __class__.Sm1S1.Null:
answer += "." + str(self._sm1S1)
return answer
def getSm(self):
return self._sm
def getSm1(self):
return self._sm1
def getSm1S1(self):
return self._sm1S1
def _e1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1 = self._sm1
if aSm1 is __class__.Sm1.s1:
self.exitSm1S1()
self.setSm1S1(__class__.Sm1S1.s1a)
wasEventProcessed = True
return wasEventProcessed
def e1(self):
self.__eventQueue.put(self._e1)
def _e2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1 = self._sm1
if aSm1 is __class__.Sm1.s2:
self.setSm1(__class__.Sm1.s1)
wasEventProcessed = True
return wasEventProcessed
def e2(self):
self.__eventQueue.put(self._e2)
def _e5(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1S1 = self._sm1S1
if aSm1S1 is __class__.Sm1S1.s1a:
self.exitSm1S1()
self.setSm1S1(__class__.Sm1S1.s1b)
wasEventProcessed = True
return wasEventProcessed
def e5(self):
self.__eventQueue.put(self._e5)
def _e6(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1S1 = self._sm1S1
if aSm1S1 is __class__.Sm1S1.s1b:
self.exitSm1()
self.setSm1(__class__.Sm1.s2)
wasEventProcessed = True
return wasEventProcessed
def e6(self):
self.__eventQueue.put(self._e6)
def setSm(self, aSm):
self._sm = aSm
return True
def exitSm1(self):
if self._sm1 is __class__.Sm1.s1:
self.exitSm1S1()
def setSm1(self, aSm1):
self._sm1 = aSm1
if self._sm1 is __class__.Sm1.s1:
if self._sm1S1 is __class__.Sm1S1.Null:
self.setSm1S1(__class__.Sm1S1.s1a)
def exitSm1S1(self):
if self._sm1S1 is __class__.Sm1S1.s1a:
self.setSm1S1(__class__.Sm1S1.Null)
elif self._sm1S1 is __class__.Sm1S1.s1b:
self.setSm1S1(__class__.Sm1S1.Null)
def setSm1S1(self, aSm1S1):
self._sm1S1 = aSm1S1
if self._sm1 is not __class__.Sm1.s1 and aSm1S1 is not __class__.Sm1S1.Null:
self.setSm1(__class__.Sm1.s1)
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class NestedStatesWthSameEventNames:
class Sm(Enum):
nestedState1 = "nestedState1"
nestedState2 = "nestedState2"
state5 = "state5"
def __str__(self):
return self.value
class SmNestedState1(Enum):
Null = "Null"
state1 = "state1"
state2 = "state2"
def __str__(self):
return self.value
class SmNestedState2(Enum):
Null = "Null"
state3 = "state3"
state4 = "state4"
def __str__(self):
return self.value
def __init__(self):
self._sm = None
self._smNestedState1 = None
self._smNestedState2 = None
self._deleted = False
self.setSmNestedState1(__class__.SmNestedState1.Null)
self.setSmNestedState2(__class__.SmNestedState2.Null)
self.setSm(__class__.Sm.nestedState1)
def getSmFullName(self):
answer = str(self._sm)
if self._smNestedState1 is not __class__.SmNestedState1.Null:
answer += "." + str(self._smNestedState1)
if self._smNestedState2 is not __class__.SmNestedState2.Null:
answer += "." + str(self._smNestedState2)
return answer
def getSm(self):
return self._sm
def getSmNestedState1(self):
return self._smNestedState1
def getSmNestedState2(self):
return self._smNestedState2
def e1(self):
if self._deleted:
return False
wasEventProcessed = False
aSmNestedState1 = self._smNestedState1
if aSmNestedState1 is __class__.SmNestedState1.state1:
self.exitSmNestedState1()
self.setSmNestedState1(__class__.SmNestedState1.state2)
wasEventProcessed = True
else:
wasEventProcessed = self.unspecified(self.getSmNestedState1().value, "e1") or wasEventProcessed
return wasEventProcessed
def unspecified(self, state, event):
if self._deleted:
return False
wasEventProcessed = False
aSmNestedState1 = self._smNestedState1
aSmNestedState2 = self._smNestedState2
if aSmNestedState1 is __class__.SmNestedState1.state1:
self.exitSmNestedState1()
self.setSmNestedState1(__class__.SmNestedState1.state1)
wasEventProcessed = True
if aSmNestedState2 is __class__.SmNestedState2.state4:
self.exitSm()
self.setSm(__class__.Sm.nestedState2)
wasEventProcessed = True
return wasEventProcessed
def e2(self):
if self._deleted:
return False
wasEventProcessed = False
aSmNestedState1 = self._smNestedState1
if aSmNestedState1 is __class__.SmNestedState1.state2:
self.exitSm()
self.setSm(__class__.Sm.state5)
wasEventProcessed = True
return wasEventProcessed
def e4(self):
if self._deleted:
return False
wasEventProcessed = False
aSmNestedState2 = self._smNestedState2
if aSmNestedState2 is __class__.SmNestedState2.state4:
self.exitSm()
self.setSm(__class__.Sm.state5)
wasEventProcessed = True
else:
wasEventProcessed = self.unspecified(self.getSmNestedState2().value, "e4") or wasEventProcessed
return wasEventProcessed
def exitSm(self):
if self._sm is __class__.Sm.nestedState1:
self.exitSmNestedState1()
elif self._sm is __class__.Sm.nestedState2:
self.exitSmNestedState2()
def setSm(self, aSm):
self._sm = aSm
if self._sm is __class__.Sm.nestedState1:
if self._smNestedState1 is __class__.SmNestedState1.Null:
self.setSmNestedState1(__class__.SmNestedState1.state1)
elif self._sm is __class__.Sm.nestedState2:
if self._smNestedState2 is __class__.SmNestedState2.Null:
self.setSmNestedState2(__class__.SmNestedState2.state3)
def exitSmNestedState1(self):
if self._smNestedState1 is __class__.SmNestedState1.state1:
self.setSmNestedState1(__class__.SmNestedState1.Null)
elif self._smNestedState1 is __class__.SmNestedState1.state2:
self.setSmNestedState1(__class__.SmNestedState1.Null)
def setSmNestedState1(self, aSmNestedState1):
self._smNestedState1 = aSmNestedState1
if self._sm is not __class__.Sm.nestedState1 and aSmNestedState1 is not __class__.SmNestedState1.Null:
self.setSm(__class__.Sm.nestedState1)
def exitSmNestedState2(self):
if self._smNestedState2 is __class__.SmNestedState2.state3:
self.setSmNestedState2(__class__.SmNestedState2.Null)
elif self._smNestedState2 is __class__.SmNestedState2.state4:
self.setSmNestedState2(__class__.SmNestedState2.Null)
def setSmNestedState2(self, aSmNestedState2):
self._smNestedState2 = aSmNestedState2
if self._sm is not __class__.Sm.nestedState2 and aSmNestedState2 is not __class__.SmNestedState2.Null:
self.setSm(__class__.Sm.nestedState2)
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class LightFixture:
class Bulb(Enum):
Off = "Off"
On = "On"
def __str__(self):
return self.value
class BulbOn(Enum):
Null = "Null"
Normal = "Normal"
Dimmed = "Dimmed"
def __str__(self):
return self.value
def __init__(self):
self._bulb = None
self._bulbOn = None
self._deleted = False
self.setBulbOn(__class__.BulbOn.Null)
self.setBulb(__class__.Bulb.Off)
def getBulbFullName(self):
answer = str(self._bulb)
if self._bulbOn is not __class__.BulbOn.Null:
answer += "." + str(self._bulbOn)
return answer
def getBulb(self):
return self._bulb
def getBulbOn(self):
return self._bulbOn
def flip(self):
if self._deleted:
return False
wasEventProcessed = False
aBulb = self._bulb
if aBulb is __class__.Bulb.Off:
self.setBulb(__class__.Bulb.On)
wasEventProcessed = True
elif aBulb is __class__.Bulb.On:
self.exitBulb()
self.setBulb(__class__.Bulb.Off)
wasEventProcessed = True
return wasEventProcessed
def touch(self):
if self._deleted:
return False
wasEventProcessed = False
aBulbOn = self._bulbOn
if aBulbOn is __class__.BulbOn.Normal:
self.exitBulbOn()
self.setBulbOn(__class__.BulbOn.Dimmed)
wasEventProcessed = True
elif aBulbOn is __class__.BulbOn.Dimmed:
self.exitBulb()
self.setBulb(__class__.Bulb.Off)
wasEventProcessed = True
return wasEventProcessed
def exitBulb(self):
if self._bulb is __class__.Bulb.On:
self.exitBulbOn()
def setBulb(self, aBulb):
self._bulb = aBulb
if self._bulb is __class__.Bulb.On:
if self._bulbOn is __class__.BulbOn.Null:
self.setBulbOn(__class__.BulbOn.Normal)
def exitBulbOn(self):
if self._bulbOn is __class__.BulbOn.Normal:
self.setBulbOn(__class__.BulbOn.Null)
elif self._bulbOn is __class__.BulbOn.Dimmed:
self.setBulbOn(__class__.BulbOn.Null)
def setBulbOn(self, aBulbOn):
self._bulbOn = aBulbOn
if self._bulb is not __class__.Bulb.On and aBulbOn is not __class__.BulbOn.Null:
self.setBulb(__class__.Bulb.On)
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class LightFixture:
class Light(Enum):
On = "On"
Off = "Off"
def __str__(self):
return self.value
def __init__(self):
self._light = None
self._deleted = False
self.setLight(__class__.Light.On)
if self._deleted:
return
def getLightFullName(self):
answer = str(self._light)
return answer
def getLight(self):
return self._light
def flip(self):
if self._deleted:
return False
wasEventProcessed = False
aLight = self._light
if aLight is __class__.Light.On:
self.setLight(__class__.Light.Off)
wasEventProcessed = True
elif aLight is __class__.Light.Off:
self.setLight(__class__.Light.On)
wasEventProcessed = True
return wasEventProcessed
def setLight(self, aLight):
print("About to flip")
if self._deleted:
return
self._light = aLight
print("Just flipped")
if self._deleted:
return
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class LightFixture:
class Bulb(Enum):
On = "On"
Off = "Off"
Amber = "Amber"
def __str__(self):
return self.value
def __init__(self):
self._brightness = 0
self._bulb = None
self._deleted = False
self.setBulb(__class__.Bulb.On)
def setBrightness(self, aBrightness):
self._brightness = aBrightness
return True
def getBrightness(self):
return self._brightness
def getBulbFullName(self):
answer = str(self._bulb)
return answer
def getBulb(self):
return self._bulb
def push(self):
if self._deleted:
return False
wasEventProcessed = False
aBulb = self._bulb
if aBulb is __class__.Bulb.On:
if self.getBrightness() < 1:
self.setBulb(__class__.Bulb.Off)
wasEventProcessed = True
elif self.getBrightness() > 10:
self.setBulb(__class__.Bulb.Amber)
wasEventProcessed = True
return wasEventProcessed
def setBulb(self, aBulb):
self._bulb = aBulb
def delete(self):
self._deleted = True
def __str__(self):
return (super().__str__() + "["
+ "brightness:" + str(self.getBrightness())
+ "]")
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Course:
class Status(Enum):
Open = "Open"
Closed = "Closed"
def __str__(self):
return self.value
def __init__(self):
self._status = None
self._deleted = False
self.setStatus(__class__.Status.Open)
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def register(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Open:
self.setStatus(__class__.Status.Closed)
wasEventProcessed = True
return wasEventProcessed
def deregister(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Closed:
self.setStatus(__class__.Status.Open)
wasEventProcessed = True
return wasEventProcessed
def setStatus(self, aStatus):
self._status = aStatus
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Garage:
class GarageDoor(Enum):
Open = "Open"
Closing = "Closing"
def __str__(self):
return self.value
def __init__(self, aEntranceClear):
self._entranceClear = aEntranceClear
self._garageDoor = None
self._deleted = False
self.setGarageDoor(__class__.GarageDoor.Open)
def setEntranceClear(self, aEntranceClear):
self._entranceClear = aEntranceClear
return True
def getEntranceClear(self):
return self._entranceClear
def isEntranceClear(self):
return self._entranceClear
def getGarageDoorFullName(self):
answer = str(self._garageDoor)
return answer
def getGarageDoor(self):
return self._garageDoor
def pressButton(self):
if self._deleted:
return False
wasEventProcessed = False
aGarageDoor = self._garageDoor
if aGarageDoor is __class__.GarageDoor.Open:
if self.getEntranceClear():
self.setGarageDoor(__class__.GarageDoor.Closing)
wasEventProcessed = True
return wasEventProcessed
def setGarageDoor(self, aGarageDoor):
self._garageDoor = aGarageDoor
def delete(self):
self._deleted = True
def __str__(self):
return (super().__str__() + "["
+ "entranceClear:" + str(self.getEntranceClear())
+ "]")
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class Course:
class Status(Enum):
Open = "Open"
Full = "Full"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __canProcess(self, call):
name = call.__name__
return (self._status is __class__.Status.Open and name in ("_register",)
or self._status is __class__.Status.Full and name in ("_reject",))
def __init__(self):
self.__eventQueue = __class__.MessageQueue(self.__canProcess)
self._status = None
self._deleted = False
self.setStatus(__class__.Status.Open)
self.__eventQueue.start()
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def _register(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Open:
self.setStatus(__class__.Status.Full)
wasEventProcessed = True
return wasEventProcessed
def register(self):
self.__eventQueue.put(self._register)
def _reject(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Full:
self.setStatus(__class__.Status.Full)
wasEventProcessed = True
return wasEventProcessed
def reject(self):
self.__eventQueue.put(self._reject)
def setStatus(self, aStatus):
self._status = aStatus
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class Course:
class Status(Enum):
Open = "Open"
Full = "Full"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __init__(self):
self.__eventQueue = __class__.MessageQueue(None)
self._status = None
self._deleted = False
self.setStatus(__class__.Status.Open)
self.__eventQueue.start()
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def _register(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Open:
self.setStatus(__class__.Status.Full)
wasEventProcessed = True
return wasEventProcessed
def register(self):
self.__eventQueue.put(self._register)
def _reject(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Full:
self.setStatus(__class__.Status.Full)
wasEventProcessed = True
return wasEventProcessed
def reject(self):
self.__eventQueue.put(self._reject)
def setStatus(self, aStatus):
self._status = aStatus
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Student:
class Grade(Enum):
Pass = "Pass"
def __str__(self):
return self.value
def __init__(self):
self._grade = None
self._deleted = False
self.setGrade(__class__.Grade.Pass)
def getGradeFullName(self):
answer = str(self._grade)
return answer
def getGrade(self):
return self._grade
def setGrade(self, aGrade):
self._grade = aGrade
return True
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class X:
class Sm(Enum):
s0 = "s0"
s1 = "s1"
def __str__(self):
return self.value
class SmS0T1(Enum):
Null = "Null"
t1 = "t1"
def __str__(self):
return self.value
class SmS0T2(Enum):
Null = "Null"
t2 = "t2"
t3 = "t3"
def __str__(self):
return self.value
class SmS1T4(Enum):
Null = "Null"
t4 = "t4"
t5 = "t5"
def __str__(self):
return self.value
class SmS1T6(Enum):
Null = "Null"
t6 = "t6"
t7 = "t7"
def __str__(self):
return self.value
def __init__(self):
self._sm = None
self._smVisit = 0
self._smS0T1 = None
self._smS0T2 = None
self._smS1T4 = None
self._smS1T6 = None
self._deleted = False
self.setSmS0T1(__class__.SmS0T1.Null)
self.setSmS0T2(__class__.SmS0T2.Null)
self.setSmS1T4(__class__.SmS1T4.Null)
self.setSmS1T6(__class__.SmS1T6.Null)
self.setSm(__class__.Sm.s0)
def getSmFullName(self):
answer = str(self._sm)
if self._smS0T1 is not __class__.SmS0T1.Null:
answer += "." + str(self._smS0T1)
if self._smS0T2 is not __class__.SmS0T2.Null:
answer += "." + str(self._smS0T2)
if self._smS1T4 is not __class__.SmS1T4.Null:
answer += "." + str(self._smS1T4)
if self._smS1T6 is not __class__.SmS1T6.Null:
answer += "." + str(self._smS1T6)
return answer
def getSm(self):
return self._sm
def getSmS0T1(self):
return self._smS0T1
def getSmS0T2(self):
return self._smS0T2
def getSmS1T4(self):
return self._smS1T4
def getSmS1T6(self):
return self._smS1T6
def goS1(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS0T1 = self._smS0T1
if aSmS0T1 is __class__.SmS0T1.t1:
self.exitSm()
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def goT3(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS0T2 = self._smS0T2
if aSmS0T2 is __class__.SmS0T2.t2:
self.exitSmS0T2()
self.setSmS0T2(__class__.SmS0T2.t3)
wasEventProcessed = True
return wasEventProcessed
def goT5(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1T4 = self._smS1T4
if aSmS1T4 is __class__.SmS1T4.t4:
self.exitSmS1T4()
self.setSmS1T4(__class__.SmS1T4.t5)
wasEventProcessed = True
return wasEventProcessed
def goT7(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1T6 = self._smS1T6
if aSmS1T6 is __class__.SmS1T6.t6:
self.exitSmS1T6()
self.setSmS1T6(__class__.SmS1T6.t7)
wasEventProcessed = True
return wasEventProcessed
def exitSm(self):
self._smVisit += 1
if self._sm is __class__.Sm.s0:
self.exitSmS0T1()
self.exitSmS0T2()
elif self._sm is __class__.Sm.s1:
self.exitSmS1T4()
self.exitSmS1T6()
def setSm(self, aSm):
self._sm = aSm
self._smVisit += 1
visit = self._smVisit
if self._sm is __class__.Sm.s0:
if self._smS0T1 is __class__.SmS0T1.Null:
self.setSmS0T1(__class__.SmS0T1.t1)
if self._smVisit != visit:
return
if self._smS0T2 is __class__.SmS0T2.Null:
self.setSmS0T2(__class__.SmS0T2.t2)
elif self._sm is __class__.Sm.s1:
if self._smS1T4 is __class__.SmS1T4.Null:
self.setSmS1T4(__class__.SmS1T4.t4)
if self._smVisit != visit:
return
if self._smS1T6 is __class__.SmS1T6.Null:
self.setSmS1T6(__class__.SmS1T6.t6)
def exitSmS0T1(self):
if self._smS0T1 is __class__.SmS0T1.t1:
self.setSmS0T1(__class__.SmS0T1.Null)
def setSmS0T1(self, aSmS0T1):
self._smS0T1 = aSmS0T1
if self._sm is not __class__.Sm.s0 and aSmS0T1 is not __class__.SmS0T1.Null:
self.setSm(__class__.Sm.s0)
def exitSmS0T2(self):
if self._smS0T2 is __class__.SmS0T2.t2:
self.setSmS0T2(__class__.SmS0T2.Null)
elif self._smS0T2 is __class__.SmS0T2.t3:
self.setSmS0T2(__class__.SmS0T2.Null)
def setSmS0T2(self, aSmS0T2):
self._smS0T2 = aSmS0T2
if self._sm is not __class__.Sm.s0 and aSmS0T2 is not __class__.SmS0T2.Null:
self.setSm(__class__.Sm.s0)
def exitSmS1T4(self):
if self._smS1T4 is __class__.SmS1T4.t4:
self.setSmS1T4(__class__.SmS1T4.Null)
elif self._smS1T4 is __class__.SmS1T4.t5:
self.setSmS1T4(__class__.SmS1T4.Null)
def setSmS1T4(self, aSmS1T4):
self._smS1T4 = aSmS1T4
if self._sm is not __class__.Sm.s1 and aSmS1T4 is not __class__.SmS1T4.Null:
self.setSm(__class__.Sm.s1)
def exitSmS1T6(self):
if self._smS1T6 is __class__.SmS1T6.t6:
self.setSmS1T6(__class__.SmS1T6.Null)
elif self._smS1T6 is __class__.SmS1T6.t7:
self.setSmS1T6(__class__.SmS1T6.Null)
def setSmS1T6(self, aSmS1T6):
self._smS1T6 = aSmS1T6
if self._sm is not __class__.Sm.s1 and aSmS1T6 is not __class__.SmS1T6.Null:
self.setSm(__class__.Sm.s1)
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class Mentor:
class Status(Enum):
Ok = "Ok"
NotOkay = "NotOkay"
NotOk = "NotOk"
def __str__(self):
return self.value
class TimedEventHandler:
def __init__(self, controller, timeoutMethodName, howLongInSeconds):
self._controller = controller
self._timeoutMethodName = timeoutMethodName
self._timer = threading.Timer(howLongInSeconds, self.run)
self._timer.daemon = False
def start(self):
self._timer.start()
def stop(self):
self._timer.cancel()
def isCurrent(self, handler, state, armedState):
return not self._timer.finished.is_set() and not self._controller._deleted and handler is self and state is armedState
def run(self):
controller = self._controller
if self._timeoutMethodName == "timeoutOkToNotOk":
if self.isCurrent(controller._timeoutOkToNotOkHandler, controller._status, Mentor.Status.Ok):
if not controller.timeoutOkToNotOk() and self.isCurrent(controller._timeoutOkToNotOkHandler, controller._status, Mentor.Status.Ok):
controller.startTimeoutOkToNotOkHandler()
elif self._timeoutMethodName == "timeoutNotOkayToOk":
if self.isCurrent(controller._timeoutNotOkayToOkHandler, controller._status, Mentor.Status.NotOkay):
if not controller.timeoutNotOkayToOk() and self.isCurrent(controller._timeoutNotOkayToOkHandler, controller._status, Mentor.Status.NotOkay):
controller.startTimeoutNotOkayToOkHandler()
def __init__(self):
self._howLongUntilOk = 3
self._status = None
self._statusVisit = 0
self._timeoutOkToNotOkHandler = None
self._timeoutNotOkayToOkHandler = None
self._deleted = False
self.setStatus(__class__.Status.Ok)
if self._deleted:
return
def setHowLongUntilOk(self, aHowLongUntilOk):
self._howLongUntilOk = aHowLongUntilOk
return True
def getHowLongUntilOk(self):
return self._howLongUntilOk
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def timeoutOkToNotOk(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Ok:
self.exitStatus()
if self._deleted:
return True
self.setStatus(__class__.Status.NotOk)
wasEventProcessed = True
return wasEventProcessed
def timeoutNotOkayToOk(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.NotOkay:
self.exitStatus()
if self._deleted:
return True
self.setStatus(__class__.Status.Ok)
wasEventProcessed = True
return wasEventProcessed
def exitStatus(self):
self._statusVisit += 1
if self._status is __class__.Status.Ok:
self.stopTimeoutOkToNotOkHandler()
elif self._status is __class__.Status.NotOkay:
self.stopTimeoutNotOkayToOkHandler()
def setStatus(self, aStatus):
self._status = aStatus
self._statusVisit += 1
if self._status is __class__.Status.Ok:
self.startTimeoutOkToNotOkHandler()
elif self._status is __class__.Status.NotOkay:
self.startTimeoutNotOkayToOkHandler()
def startTimeoutOkToNotOkHandler(self):
if self._deleted:
return
if self._timeoutOkToNotOkHandler is not None:
self._timeoutOkToNotOkHandler.stop()
visit = self._statusVisit
delay = 4
if self._deleted or self._statusVisit != visit:
return
self._timeoutOkToNotOkHandler = __class__.TimedEventHandler(self, "timeoutOkToNotOk", delay)
self._timeoutOkToNotOkHandler.start()
def stopTimeoutOkToNotOkHandler(self):
if self._timeoutOkToNotOkHandler is not None:
self._timeoutOkToNotOkHandler.stop()
def startTimeoutNotOkayToOkHandler(self):
if self._deleted:
return
if self._timeoutNotOkayToOkHandler is not None:
self._timeoutNotOkayToOkHandler.stop()
visit = self._statusVisit
delay = self._howLongUntilOk
if self._deleted or self._statusVisit != visit:
return
self._timeoutNotOkayToOkHandler = __class__.TimedEventHandler(self, "timeoutNotOkayToOk", delay)
self._timeoutNotOkayToOkHandler.start()
def stopTimeoutNotOkayToOkHandler(self):
if self._timeoutNotOkayToOkHandler is not None:
self._timeoutNotOkayToOkHandler.stop()
def delete(self):
self._deleted = True
self.stopTimeoutOkToNotOkHandler()
self.stopTimeoutNotOkayToOkHandler()
def __str__(self):
return (super().__str__() + "["
+ "howLongUntilOk:" + str(self.getHowLongUntilOk())
+ "]")
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
s3 = "s3"
s4 = "s4"
def __str__(self):
return self.value
class Sm2(Enum):
sm21 = "sm21"
sm22 = "sm22"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __init__(self):
self._ev = ""
self.__eventQueue = __class__.MessageQueue(None)
self._sm = None
self._sm2 = None
self._deleted = False
self.setSm(__class__.Sm.s1)
if self._deleted:
return
self.setSm2(__class__.Sm2.sm21)
if self._deleted:
return
self.__eventQueue.start()
def setEv(self, aEv):
self._ev = aEv
return True
def getEv(self):
return self._ev
def getSmFullName(self):
answer = str(self._sm)
return answer
def getSm2FullName(self):
answer = str(self._sm2)
return answer
def getSm(self):
return self._sm
def getSm2(self):
return self._sm2
def _ev1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
aSm2 = self._sm2
if aSm is __class__.Sm.s1:
self._ev = "ev1"
if self._deleted:
return True
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
if self._deleted:
return True
if aSm2 is __class__.Sm2.sm21:
self._ev = "ev1 in sm2"
if self._deleted:
return True
self.setSm2(__class__.Sm2.sm22)
wasEventProcessed = True
if self._deleted:
return wasEventProcessed
if wasEventProcessed:
print(self._ev)
if self._deleted:
return wasEventProcessed
return wasEventProcessed
def ev1(self):
self.__eventQueue.put(self._ev1)
def _ev5(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self._ev = "ev5"
if self._deleted:
return True
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
if self._deleted:
return wasEventProcessed
if wasEventProcessed:
print(self._ev)
if self._deleted:
return wasEventProcessed
return wasEventProcessed
def ev5(self):
self.__eventQueue.put(self._ev5)
def _ev2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self._ev = "ev2"
if self._deleted:
return True
self.setSm(__class__.Sm.s3)
wasEventProcessed = True
if self._deleted:
return wasEventProcessed
if wasEventProcessed:
print(self._ev)
if self._deleted:
return wasEventProcessed
return wasEventProcessed
def ev2(self):
self.__eventQueue.put(self._ev2)
def _ev3(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s3:
self._ev = "ev3"
if self._deleted:
return True
self.setSm(__class__.Sm.s4)
wasEventProcessed = True
if self._deleted:
return wasEventProcessed
if wasEventProcessed:
print(self._ev)
if self._deleted:
return wasEventProcessed
return wasEventProcessed
def ev3(self):
self.__eventQueue.put(self._ev3)
def _ev4(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s4:
self._ev = "ev4"
if self._deleted:
return True
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
if self._deleted:
return wasEventProcessed
if wasEventProcessed:
print(self._ev)
if self._deleted:
return wasEventProcessed
return wasEventProcessed
def ev4(self):
self.__eventQueue.put(self._ev4)
def _ev7(self):
if self._deleted:
return False
wasEventProcessed = False
aSm2 = self._sm2
if aSm2 is __class__.Sm2.sm22:
self._ev = "ev7 in sm2"
if self._deleted:
return True
self.setSm2(__class__.Sm2.sm21)
wasEventProcessed = True
if self._deleted:
return wasEventProcessed
if wasEventProcessed:
print(self._ev)
if self._deleted:
return wasEventProcessed
return wasEventProcessed
def ev7(self):
self.__eventQueue.put(self._ev7)
def setSm(self, aSm):
self._sm = aSm
def setSm2(self, aSm2):
self._sm2 = aSm2
def delete(self):
self._deleted = True
self.__eventQueue.stop()
def __str__(self):
return (super().__str__() + "["
+ "ev:" + str(self.getEv())
+ "]")
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
s3 = "s3"
s4 = "s4"
def __str__(self):
return self.value
class Sm2(Enum):
sm21 = "sm21"
sm22 = "sm22"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __init__(self):
self.__eventQueue = __class__.MessageQueue(None)
self._sm = None
self._sm2 = None
self._deleted = False
self.setSm(__class__.Sm.s1)
self.setSm2(__class__.Sm2.sm21)
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
return answer
def getSm2FullName(self):
answer = str(self._sm2)
return answer
def getSm(self):
return self._sm
def getSm2(self):
return self._sm2
def _ev1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
aSm2 = self._sm2
if aSm is __class__.Sm.s1:
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
if aSm2 is __class__.Sm2.sm21:
self.setSm2(__class__.Sm2.sm22)
wasEventProcessed = True
return wasEventProcessed
def ev1(self):
self.__eventQueue.put(self._ev1)
def _ev5(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def ev5(self):
self.__eventQueue.put(self._ev5)
def _ev2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self.setSm(__class__.Sm.s3)
wasEventProcessed = True
return wasEventProcessed
def ev2(self):
self.__eventQueue.put(self._ev2)
def _ev3(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s3:
self.setSm(__class__.Sm.s4)
wasEventProcessed = True
return wasEventProcessed
def ev3(self):
self.__eventQueue.put(self._ev3)
def _ev4(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s4:
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def ev4(self):
self.__eventQueue.put(self._ev4)
def _ev7(self):
if self._deleted:
return False
wasEventProcessed = False
aSm2 = self._sm2
if aSm2 is __class__.Sm2.sm22:
self.setSm2(__class__.Sm2.sm21)
wasEventProcessed = True
return wasEventProcessed
def ev7(self):
self.__eventQueue.put(self._ev7)
def setSm(self, aSm):
self._sm = aSm
def setSm2(self, aSm2):
self._sm2 = aSm2
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
def __str__(self):
return self.value
class Sm1(Enum):
s3 = "s3"
s4 = "s4"
s5 = "s5"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __canProcess(self, call):
name = call.__name__
return (self._sm is __class__.Sm.s1 and name in ("_e1",)
or self._sm is __class__.Sm.s2 and name in ("_e2",)
or self._sm1 is __class__.Sm1.s3 and name in ("_e3",)
or self._sm1 is __class__.Sm1.s4 and name in ("_e4",))
def __init__(self):
self.__eventQueue = __class__.MessageQueue(self.__canProcess)
self._sm = None
self._sm1 = None
self._deleted = False
self.setSm(__class__.Sm.s1)
self.setSm1(__class__.Sm1.s3)
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
return answer
def getSm1FullName(self):
answer = str(self._sm1)
return answer
def getSm(self):
return self._sm
def getSm1(self):
return self._sm1
def _e1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def e1(self):
self.__eventQueue.put(self._e1)
def _e2(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def e2(self):
self.__eventQueue.put(self._e2)
def _e3(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1 = self._sm1
if aSm1 is __class__.Sm1.s3:
self.setSm1(__class__.Sm1.s4)
wasEventProcessed = True
return wasEventProcessed
def e3(self):
self.__eventQueue.put(self._e3)
def _e4(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1 = self._sm1
if aSm1 is __class__.Sm1.s4:
self.setSm1(__class__.Sm1.s3)
wasEventProcessed = True
return wasEventProcessed
def e4(self):
self.__eventQueue.put(self._e4)
def setSm(self, aSm):
self._sm = aSm
def setSm1(self, aSm1):
self._sm1 = aSm1
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class Light:
class Bulb(Enum):
Off = "Off"
On = "On"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __init__(self):
self.__eventQueue = __class__.MessageQueue(None)
self._bulb = None
self._deleted = False
self.setBulb(__class__.Bulb.Off)
self.__eventQueue.start()
def getBulbFullName(self):
answer = str(self._bulb)
return answer
def getBulb(self):
return self._bulb
def __autotransition1__(self):
if self._deleted:
return False
wasEventProcessed = False
aBulb = self._bulb
if aBulb is __class__.Bulb.Off:
self.setBulb(__class__.Bulb.On)
wasEventProcessed = True
return wasEventProcessed
def setBulb(self, aBulb):
self._bulb = aBulb
if self._bulb is __class__.Bulb.Off:
self.__autotransition1__()
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
def __str__(self):
return self.value
class SmS1(Enum):
Null = "Null"
s1a = "s1a"
s1b = "s1b"
def __str__(self):
return self.value
class SmS2(Enum):
Null = "Null"
s2a = "s2a"
s2b = "s2b"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __canProcess(self, call):
name = call.__name__
return (self._sm is __class__.Sm.s1 and name in ("_e1",)
or self._sm is __class__.Sm.s2 and name in ("_e4",)
or self._smS1 is __class__.SmS1.s1a and name in ("_e2",)
or self._smS1 is __class__.SmS1.s1b and name in ("_e3",)
or self._smS2 is __class__.SmS2.s2a and name in ("_e5",)
or self._smS2 is __class__.SmS2.s2b and name in ("_e6",))
def __init__(self):
self.__eventQueue = __class__.MessageQueue(self.__canProcess)
self._sm = None
self._smS1 = None
self._smS2 = None
self._deleted = False
self.setSmS1(__class__.SmS1.Null)
self.setSmS2(__class__.SmS2.Null)
self.setSm(__class__.Sm.s1)
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
if self._smS1 is not __class__.SmS1.Null:
answer += "." + str(self._smS1)
if self._smS2 is not __class__.SmS2.Null:
answer += "." + str(self._smS2)
return answer
def getSm(self):
return self._sm
def getSmS1(self):
return self._smS1
def getSmS2(self):
return self._smS2
def _e1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.exitSmS1()
self.setSmS1(__class__.SmS1.s1a)
wasEventProcessed = True
return wasEventProcessed
def e1(self):
self.__eventQueue.put(self._e1)
def _e4(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self.exitSm()
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def e4(self):
self.__eventQueue.put(self._e4)
def _e2(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s1a:
self.exitSmS1()
self.setSmS1(__class__.SmS1.s1b)
wasEventProcessed = True
return wasEventProcessed
def e2(self):
self.__eventQueue.put(self._e2)
def _e3(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s1b:
self.exitSm()
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def e3(self):
self.__eventQueue.put(self._e3)
def _e5(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS2 = self._smS2
if aSmS2 is __class__.SmS2.s2a:
self.exitSmS2()
self.setSmS2(__class__.SmS2.s2b)
wasEventProcessed = True
return wasEventProcessed
def e5(self):
self.__eventQueue.put(self._e5)
def _e6(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS2 = self._smS2
if aSmS2 is __class__.SmS2.s2b:
self.exitSmS2()
self.setSmS2(__class__.SmS2.s2a)
wasEventProcessed = True
return wasEventProcessed
def e6(self):
self.__eventQueue.put(self._e6)
def exitSm(self):
if self._sm is __class__.Sm.s1:
self.exitSmS1()
elif self._sm is __class__.Sm.s2:
self.exitSmS2()
def setSm(self, aSm):
self._sm = aSm
if self._sm is __class__.Sm.s1:
if self._smS1 is __class__.SmS1.Null:
self.setSmS1(__class__.SmS1.s1a)
elif self._sm is __class__.Sm.s2:
if self._smS2 is __class__.SmS2.Null:
self.setSmS2(__class__.SmS2.s2a)
def exitSmS1(self):
if self._smS1 is __class__.SmS1.s1a:
self.setSmS1(__class__.SmS1.Null)
elif self._smS1 is __class__.SmS1.s1b:
self.setSmS1(__class__.SmS1.Null)
def setSmS1(self, aSmS1):
self._smS1 = aSmS1
if self._sm is not __class__.Sm.s1 and aSmS1 is not __class__.SmS1.Null:
self.setSm(__class__.Sm.s1)
def exitSmS2(self):
if self._smS2 is __class__.SmS2.s2a:
self.setSmS2(__class__.SmS2.Null)
elif self._smS2 is __class__.SmS2.s2b:
self.setSmS2(__class__.SmS2.Null)
def setSmS2(self, aSmS2):
self._smS2 = aSmS2
if self._sm is not __class__.Sm.s2 and aSmS2 is not __class__.SmS2.Null:
self.setSm(__class__.Sm.s2)
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm(Enum):
s1 = "s1"
s2 = "s2"
s3 = "s3"
def __str__(self):
return self.value
class SmS1(Enum):
Null = "Null"
s1a = "s1a"
s1b = "s1b"
def __str__(self):
return self.value
class SmS2(Enum):
Null = "Null"
s2a = "s2a"
s2b = "s2b"
def __str__(self):
return self.value
class SmS3(Enum):
Null = "Null"
s3a = "s3a"
s3b = "s3b"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __canProcess(self, call):
name = call.__name__
return (self._sm is __class__.Sm.s1 and name in ("_e1",)
or self._sm is __class__.Sm.s2 and name in ("_e4",)
or self._sm is __class__.Sm.s3 and name in ("_e7",)
or self._smS1 is __class__.SmS1.s1a and name in ("_e2",)
or self._smS1 is __class__.SmS1.s1b and name in ("_e3",)
or self._smS2 is __class__.SmS2.s2a and name in ("_e5",)
or self._smS2 is __class__.SmS2.s2b and name in ("_e6",)
or self._smS3 is __class__.SmS3.s3a and name in ("_e8",)
or self._smS3 is __class__.SmS3.s3b and name in ("_e9",))
def __init__(self):
self.__eventQueue = __class__.MessageQueue(self.__canProcess)
self._sm = None
self._smS1 = None
self._smS2 = None
self._smS3 = None
self._deleted = False
self.setSmS1(__class__.SmS1.Null)
self.setSmS2(__class__.SmS2.Null)
self.setSmS3(__class__.SmS3.Null)
self.setSm(__class__.Sm.s1)
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
if self._smS1 is not __class__.SmS1.Null:
answer += "." + str(self._smS1)
if self._smS2 is not __class__.SmS2.Null:
answer += "." + str(self._smS2)
if self._smS3 is not __class__.SmS3.Null:
answer += "." + str(self._smS3)
return answer
def getSm(self):
return self._sm
def getSmS1(self):
return self._smS1
def getSmS2(self):
return self._smS2
def getSmS3(self):
return self._smS3
def _e1(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s1:
self.exitSmS1()
self.setSmS1(__class__.SmS1.s1a)
wasEventProcessed = True
return wasEventProcessed
def e1(self):
self.__eventQueue.put(self._e1)
def _e4(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s2:
self.exitSm()
self.setSm(__class__.Sm.s1)
wasEventProcessed = True
return wasEventProcessed
def e4(self):
self.__eventQueue.put(self._e4)
def _e7(self):
if self._deleted:
return False
wasEventProcessed = False
aSm = self._sm
if aSm is __class__.Sm.s3:
self.exitSm()
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def e7(self):
self.__eventQueue.put(self._e7)
def _e2(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s1a:
self.exitSmS1()
self.setSmS1(__class__.SmS1.s1b)
wasEventProcessed = True
return wasEventProcessed
def e2(self):
self.__eventQueue.put(self._e2)
def _e3(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS1 = self._smS1
if aSmS1 is __class__.SmS1.s1b:
self.exitSm()
self.setSm(__class__.Sm.s2)
wasEventProcessed = True
return wasEventProcessed
def e3(self):
self.__eventQueue.put(self._e3)
def _e5(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS2 = self._smS2
if aSmS2 is __class__.SmS2.s2a:
self.exitSmS2()
self.setSmS2(__class__.SmS2.s2b)
wasEventProcessed = True
return wasEventProcessed
def e5(self):
self.__eventQueue.put(self._e5)
def _e6(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS2 = self._smS2
if aSmS2 is __class__.SmS2.s2b:
self.exitSm()
self.setSm(__class__.Sm.s3)
wasEventProcessed = True
return wasEventProcessed
def e6(self):
self.__eventQueue.put(self._e6)
def _e8(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS3 = self._smS3
if aSmS3 is __class__.SmS3.s3a:
self.exitSmS3()
self.setSmS3(__class__.SmS3.s3b)
wasEventProcessed = True
return wasEventProcessed
def e8(self):
self.__eventQueue.put(self._e8)
def _e9(self):
if self._deleted:
return False
wasEventProcessed = False
aSmS3 = self._smS3
if aSmS3 is __class__.SmS3.s3b:
self.exitSm()
self.setSmS1(__class__.SmS1.s1a)
wasEventProcessed = True
return wasEventProcessed
def e9(self):
self.__eventQueue.put(self._e9)
def exitSm(self):
if self._sm is __class__.Sm.s1:
self.exitSmS1()
elif self._sm is __class__.Sm.s2:
self.exitSmS2()
elif self._sm is __class__.Sm.s3:
self.exitSmS3()
def setSm(self, aSm):
self._sm = aSm
if self._sm is __class__.Sm.s1:
if self._smS1 is __class__.SmS1.Null:
self.setSmS1(__class__.SmS1.s1a)
elif self._sm is __class__.Sm.s2:
if self._smS2 is __class__.SmS2.Null:
self.setSmS2(__class__.SmS2.s2a)
elif self._sm is __class__.Sm.s3:
if self._smS3 is __class__.SmS3.Null:
self.setSmS3(__class__.SmS3.s3a)
def exitSmS1(self):
if self._smS1 is __class__.SmS1.s1a:
self.setSmS1(__class__.SmS1.Null)
elif self._smS1 is __class__.SmS1.s1b:
self.setSmS1(__class__.SmS1.Null)
def setSmS1(self, aSmS1):
self._smS1 = aSmS1
if self._sm is not __class__.Sm.s1 and aSmS1 is not __class__.SmS1.Null:
self.setSm(__class__.Sm.s1)
def exitSmS2(self):
if self._smS2 is __class__.SmS2.s2a:
self.setSmS2(__class__.SmS2.Null)
elif self._smS2 is __class__.SmS2.s2b:
self.setSmS2(__class__.SmS2.Null)
def setSmS2(self, aSmS2):
self._smS2 = aSmS2
if self._sm is not __class__.Sm.s2 and aSmS2 is not __class__.SmS2.Null:
self.setSm(__class__.Sm.s2)
def exitSmS3(self):
if self._smS3 is __class__.SmS3.s3a:
self.setSmS3(__class__.SmS3.Null)
elif self._smS3 is __class__.SmS3.s3b:
self.setSmS3(__class__.SmS3.Null)
def setSmS3(self, aSmS3):
self._smS3 = aSmS3
if self._sm is not __class__.Sm.s3 and aSmS3 is not __class__.SmS3.Null:
self.setSm(__class__.Sm.s3)
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class X:
class Sm1(Enum):
s1 = "s1"
s2 = "s2"
def __str__(self):
return self.value
class Sm1S1(Enum):
Null = "Null"
s1a = "s1a"
s1b = "s1b"
def __str__(self):
return self.value
class Sm1S2(Enum):
Null = "Null"
s2a = "s2a"
s2b = "s2b"
def __str__(self):
return self.value
class Sm1S2S2b(Enum):
Null = "Null"
s2b1 = "s2b1"
s2b2 = "s2b2"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __canProcess(self, call):
name = call.__name__
return (self._sm1 is __class__.Sm1.s1 and name in ("_e",)
or self._sm1 is __class__.Sm1.s2 and name in ("_e",)
or self._sm1S1 is __class__.Sm1S1.s1a and name in ("_f", "_g",)
or self._sm1S1 is __class__.Sm1S1.s1b and name in ("_h", "_i", "_k",)
or self._sm1S2 is __class__.Sm1S2.s2a and name in ("_i", "_j",)
or self._sm1S2 is __class__.Sm1S2.s2b and name in ("_h", "_k",)
or self._sm1S2S2b is __class__.Sm1S2S2b.s2b1 and name in ("_m",)
or self._sm1S2S2b is __class__.Sm1S2S2b.s2b2 and name in ("_m",))
def __init__(self):
self.__eventQueue = __class__.MessageQueue(self.__canProcess)
self._sm1 = None
self._sm1S1 = None
self._sm1S2 = None
self._sm1S2Visit = 0
self._sm1S2S2b = None
self._deleted = False
self.setSm1S1(__class__.Sm1S1.Null)
self.setSm1S2(__class__.Sm1S2.Null)
self.setSm1S2S2b(__class__.Sm1S2S2b.Null)
self.setSm1(__class__.Sm1.s1)
self.__eventQueue.start()
def getSm1FullName(self):
answer = str(self._sm1)
if self._sm1S1 is not __class__.Sm1S1.Null:
answer += "." + str(self._sm1S1)
if self._sm1S2 is not __class__.Sm1S2.Null:
answer += "." + str(self._sm1S2)
if self._sm1S2S2b is not __class__.Sm1S2S2b.Null:
answer += "." + str(self._sm1S2S2b)
return answer
def getSm1(self):
return self._sm1
def getSm1S1(self):
return self._sm1S1
def getSm1S2(self):
return self._sm1S2
def getSm1S2S2b(self):
return self._sm1S2S2b
def _e(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1 = self._sm1
if aSm1 is __class__.Sm1.s1:
self.exitSm1()
self.setSm1(__class__.Sm1.s2)
wasEventProcessed = True
elif aSm1 is __class__.Sm1.s2:
self.exitSm1()
self.setSm1(__class__.Sm1.s1)
wasEventProcessed = True
return wasEventProcessed
def e(self):
self.__eventQueue.put(self._e)
def _f(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1S1 = self._sm1S1
if aSm1S1 is __class__.Sm1S1.s1a:
self.exitSm1()
self.setSm1S2(__class__.Sm1S2.s2b)
wasEventProcessed = True
return wasEventProcessed
def f(self):
self.__eventQueue.put(self._f)
def _g(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1S1 = self._sm1S1
if aSm1S1 is __class__.Sm1S1.s1a:
self.exitSm1S1()
self.setSm1S1(__class__.Sm1S1.s1a)
wasEventProcessed = True
return wasEventProcessed
def g(self):
self.__eventQueue.put(self._g)
def _h(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1S1 = self._sm1S1
aSm1S2 = self._sm1S2
if aSm1S1 is __class__.Sm1S1.s1b:
self.exitSm1S1()
self.setSm1S1(__class__.Sm1S1.s1a)
wasEventProcessed = True
if aSm1S2 is __class__.Sm1S2.s2b:
self.exitSm1S2()
self.setSm1S2(__class__.Sm1S2.s2a)
wasEventProcessed = True
return wasEventProcessed
def h(self):
self.__eventQueue.put(self._h)
def _i(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1S1 = self._sm1S1
aSm1S2 = self._sm1S2
if aSm1S1 is __class__.Sm1S1.s1b:
self.exitSm1()
self.setSm1S2(__class__.Sm1S2.s2b)
wasEventProcessed = True
if aSm1S2 is __class__.Sm1S2.s2a:
self.exitSm1S2()
self.setSm1S2(__class__.Sm1S2.s2b)
wasEventProcessed = True
return wasEventProcessed
def i(self):
self.__eventQueue.put(self._i)
def _k(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1S1 = self._sm1S1
aSm1S2 = self._sm1S2
if aSm1S1 is __class__.Sm1S1.s1b:
self.exitSm1()
self.setSm1(__class__.Sm1.s2)
wasEventProcessed = True
if aSm1S2 is __class__.Sm1S2.s2b:
self.exitSm1()
self.setSm1(__class__.Sm1.s1)
wasEventProcessed = True
return wasEventProcessed
def k(self):
self.__eventQueue.put(self._k)
def _j(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1S2 = self._sm1S2
if aSm1S2 is __class__.Sm1S2.s2a:
self.exitSm1()
self.setSm1S1(__class__.Sm1S1.s1b)
wasEventProcessed = True
return wasEventProcessed
def j(self):
self.__eventQueue.put(self._j)
def _m(self):
if self._deleted:
return False
wasEventProcessed = False
aSm1S2S2b = self._sm1S2S2b
if aSm1S2S2b is __class__.Sm1S2S2b.s2b1:
self.exitSm1S2S2b()
self.setSm1S2S2b(__class__.Sm1S2S2b.s2b2)
wasEventProcessed = True
elif aSm1S2S2b is __class__.Sm1S2S2b.s2b2:
self.exitSm1S2S2b()
self.setSm1S2S2b(__class__.Sm1S2S2b.s2b1)
wasEventProcessed = True
return wasEventProcessed
def m(self):
self.__eventQueue.put(self._m)
def exitSm1(self):
if self._sm1 is __class__.Sm1.s1:
self.exitSm1S1()
elif self._sm1 is __class__.Sm1.s2:
self.exitSm1S2()
def setSm1(self, aSm1):
self._sm1 = aSm1
if self._sm1 is __class__.Sm1.s1:
if self._sm1S1 is __class__.Sm1S1.Null:
self.setSm1S1(__class__.Sm1S1.s1a)
elif self._sm1 is __class__.Sm1.s2:
if self._sm1S2 is __class__.Sm1S2.Null:
self.setSm1S2(__class__.Sm1S2.s2a)
def exitSm1S1(self):
if self._sm1S1 is __class__.Sm1S1.s1a:
self.setSm1S1(__class__.Sm1S1.Null)
elif self._sm1S1 is __class__.Sm1S1.s1b:
self.setSm1S1(__class__.Sm1S1.Null)
def setSm1S1(self, aSm1S1):
self._sm1S1 = aSm1S1
if self._sm1 is not __class__.Sm1.s1 and aSm1S1 is not __class__.Sm1S1.Null:
self.setSm1(__class__.Sm1.s1)
def exitSm1S2(self):
self._sm1S2Visit += 1
if self._sm1S2 is __class__.Sm1S2.s2a:
self.setSm1S2(__class__.Sm1S2.Null)
elif self._sm1S2 is __class__.Sm1S2.s2b:
self.exitSm1S2S2b()
self.setSm1S2(__class__.Sm1S2.Null)
def setSm1S2(self, aSm1S2):
self._sm1S2 = aSm1S2
self._sm1S2Visit += 1
visit = self._sm1S2Visit
if self._sm1 is not __class__.Sm1.s2 and aSm1S2 is not __class__.Sm1S2.Null:
self.setSm1(__class__.Sm1.s2)
if self._sm1S2Visit != visit:
return
if self._sm1S2 is __class__.Sm1S2.s2b:
if self._sm1S2S2b is __class__.Sm1S2S2b.Null:
self.setSm1S2S2b(__class__.Sm1S2S2b.s2b1)
def exitSm1S2S2b(self):
if self._sm1S2S2b is __class__.Sm1S2S2b.s2b1:
self.setSm1S2S2b(__class__.Sm1S2S2b.Null)
elif self._sm1S2S2b is __class__.Sm1S2S2b.s2b2:
self.setSm1S2S2b(__class__.Sm1S2S2b.Null)
def setSm1S2S2b(self, aSm1S2S2b):
self._sm1S2S2b = aSm1S2S2b
if self._sm1S2 is not __class__.Sm1S2.s2b and aSm1S2S2b is not __class__.Sm1S2S2b.Null:
self.setSm1S2(__class__.Sm1S2.s2b)
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Light:
class Bulb(Enum):
Off = "Off"
On = "On"
def __str__(self):
return self.value
def __init__(self):
self._bulb = None
self._deleted = False
self.setBulb(__class__.Bulb.Off)
def getBulbFullName(self):
answer = str(self._bulb)
return answer
def getBulb(self):
return self._bulb
def __autotransition1__(self):
if self._deleted:
return False
wasEventProcessed = False
aBulb = self._bulb
if aBulb is __class__.Bulb.Off:
self.setBulb(__class__.Bulb.On)
wasEventProcessed = True
return wasEventProcessed
def setBulb(self, aBulb):
self._bulb = aBulb
if self._bulb is __class__.Bulb.Off:
self.__autotransition1__()
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class NestedStatesWthSameEventNames:
class Sm(Enum):
nestedState1 = "nestedState1"
nestedState2 = "nestedState2"
state5 = "state5"
def __str__(self):
return self.value
class SmNestedState1(Enum):
Null = "Null"
state1 = "state1"
state2 = "state2"
def __str__(self):
return self.value
class SmNestedState2(Enum):
Null = "Null"
state3 = "state3"
state4 = "state4"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __init__(self):
self.__eventQueue = __class__.MessageQueue(None)
self._sm = None
self._smNestedState1 = None
self._smNestedState2 = None
self._deleted = False
self.setSmNestedState1(__class__.SmNestedState1.Null)
self.setSmNestedState2(__class__.SmNestedState2.Null)
self.setSm(__class__.Sm.nestedState1)
self.__eventQueue.start()
def getSmFullName(self):
answer = str(self._sm)
if self._smNestedState1 is not __class__.SmNestedState1.Null:
answer += "." + str(self._smNestedState1)
if self._smNestedState2 is not __class__.SmNestedState2.Null:
answer += "." + str(self._smNestedState2)
return answer
def getSm(self):
return self._sm
def getSmNestedState1(self):
return self._smNestedState1
def getSmNestedState2(self):
return self._smNestedState2
def _moveTo(self):
if self._deleted:
return False
wasEventProcessed = False
aSmNestedState1 = self._smNestedState1
aSmNestedState2 = self._smNestedState2
if aSmNestedState1 is __class__.SmNestedState1.state1:
self.exitSmNestedState1()
self.setSmNestedState1(__class__.SmNestedState1.state2)
wasEventProcessed = True
if aSmNestedState2 is __class__.SmNestedState2.state3:
self.exitSmNestedState2()
self.setSmNestedState2(__class__.SmNestedState2.state4)
wasEventProcessed = True
return wasEventProcessed
def moveTo(self):
self.__eventQueue.put(self._moveTo)
def _transit(self):
if self._deleted:
return False
wasEventProcessed = False
aSmNestedState1 = self._smNestedState1
aSmNestedState2 = self._smNestedState2
if aSmNestedState1 is __class__.SmNestedState1.state2:
self.exitSm()
self.setSm(__class__.Sm.state5)
wasEventProcessed = True
if aSmNestedState2 is __class__.SmNestedState2.state4:
self.exitSm()
self.setSm(__class__.Sm.state5)
wasEventProcessed = True
return wasEventProcessed
def transit(self):
self.__eventQueue.put(self._transit)
def exitSm(self):
if self._sm is __class__.Sm.nestedState1:
self.exitSmNestedState1()
elif self._sm is __class__.Sm.nestedState2:
self.exitSmNestedState2()
def setSm(self, aSm):
self._sm = aSm
if self._sm is __class__.Sm.nestedState1:
if self._smNestedState1 is __class__.SmNestedState1.Null:
self.setSmNestedState1(__class__.SmNestedState1.state1)
elif self._sm is __class__.Sm.nestedState2:
if self._smNestedState2 is __class__.SmNestedState2.Null:
self.setSmNestedState2(__class__.SmNestedState2.state3)
def exitSmNestedState1(self):
if self._smNestedState1 is __class__.SmNestedState1.state1:
self.setSmNestedState1(__class__.SmNestedState1.Null)
elif self._smNestedState1 is __class__.SmNestedState1.state2:
self.setSmNestedState1(__class__.SmNestedState1.Null)
def setSmNestedState1(self, aSmNestedState1):
self._smNestedState1 = aSmNestedState1
if self._sm is not __class__.Sm.nestedState1 and aSmNestedState1 is not __class__.SmNestedState1.Null:
self.setSm(__class__.Sm.nestedState1)
def exitSmNestedState2(self):
if self._smNestedState2 is __class__.SmNestedState2.state3:
self.setSmNestedState2(__class__.SmNestedState2.Null)
elif self._smNestedState2 is __class__.SmNestedState2.state4:
self.setSmNestedState2(__class__.SmNestedState2.Null)
def setSmNestedState2(self, aSmNestedState2):
self._smNestedState2 = aSmNestedState2
if self._sm is not __class__.Sm.nestedState2 and aSmNestedState2 is not __class__.SmNestedState2.Null:
self.setSm(__class__.Sm.nestedState2)
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Course:
class Status(Enum):
Open = "Open"
Full = "Full"
def __str__(self):
return self.value
def __init__(self):
self._status = None
self._deleted = False
self.setStatus(__class__.Status.Open)
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def setStatus(self, aStatus):
self._status = aStatus
return True
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class LightFixture:
class Bulb(Enum):
On = "On"
Off = "Off"
def __str__(self):
return self.value
def __init__(self):
self._brightness = 0
self._bulb = None
self._deleted = False
self.setBulb(__class__.Bulb.On)
def setBrightness(self, aBrightness):
self._brightness = aBrightness
return True
def getBrightness(self):
return self._brightness
def getBulbFullName(self):
answer = str(self._bulb)
return answer
def getBulb(self):
return self._bulb
def push(self):
if self._deleted:
return False
wasEventProcessed = False
aBulb = self._bulb
if aBulb is __class__.Bulb.On:
if self.getBrightness() < 1:
self.setBulb(__class__.Bulb.Off)
wasEventProcessed = True
return wasEventProcessed
def setBulb(self, aBulb):
self._bulb = aBulb
def delete(self):
self._deleted = True
def __str__(self):
return (super().__str__() + "["
+ "brightness:" + str(self.getBrightness())
+ "]")
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Student:
class Grade(Enum):
Pass = "Pass"
def __str__(self):
return self.value
def __init__(self):
self._grade = None
self._deleted = False
self.setGrade(__class__.Grade.Pass)
def getGradeFullName(self):
answer = str(self._grade)
return answer
def getGrade(self):
return self._grade
def setGrade(self, aGrade):
self._grade = aGrade
return True
def delete(self):
self._deleted = True
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
import threading
class Light:
class Bulb(Enum):
Off = "Off"
On = "On"
def __str__(self):
return self.value
class MessageQueue:
def __init__(self, ready):
self._calls = []
self._ready = ready
self._started = False
self._stopped = False
self._worker = None
self._condition = threading.Condition()
def start(self):
with self._condition:
self._started = True
self._wake()
def put(self, call, *args):
with self._condition:
self._calls.append((call, args))
self._wake()
def stop(self):
with self._condition:
self._stopped = True
self._condition.notify()
def _wake(self):
if self._started and not self._stopped and self._worker is None:
self._worker = threading.Thread(target=self._run, daemon=False)
self._worker.start()
if self._worker is not None:
self._worker.isIdle = False
self._condition.notify()
def _run(self):
while True:
with self._condition:
call = None
while not self._stopped and call is None:
call = self._next()
self._worker.isIdle = call is None
if call is None and self._programIdle():
self._worker = None
return
if call is None:
self._condition.wait(0.25)
if call is None:
return
call[0](*call[1])
def _next(self):
for i, call in enumerate(self._calls):
if self._ready is None or self._ready(call[0]):
return self._calls.pop(i)
return None
def _programIdle(self):
ended = (threading.main_thread(), threading.current_thread())
return not ended[0].is_alive() and all(t in ended or t.daemon or getattr(t, "isIdle", False)
for t in threading.enumerate())
def __canProcess(self, call):
name = call.__name__
return False
def __init__(self):
self.__eventQueue = __class__.MessageQueue(self.__canProcess)
self._bulb = None
self._deleted = False
self.setBulb(__class__.Bulb.Off)
self.__eventQueue.start()
def getBulbFullName(self):
answer = str(self._bulb)
return answer
def getBulb(self):
return self._bulb
def __autotransition1__(self):
if self._deleted:
return False
wasEventProcessed = False
aBulb = self._bulb
if aBulb is __class__.Bulb.Off:
self.setBulb(__class__.Bulb.On)
wasEventProcessed = True
return wasEventProcessed
def setBulb(self, aBulb):
self._bulb = aBulb
if self._bulb is __class__.Bulb.Off:
self.__autotransition1__()
def delete(self):
self._deleted = True
self.__eventQueue.stop()
#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!
from enum import Enum
class Course:
class Status(Enum):
Open = "Open"
def __str__(self):
return self.value
def __init__(self):
self._status = None
self._deleted = False
self.setStatus(__class__.Status.Open)
def getStatusFullName(self):
answer = str(self._status)
return answer
def getStatus(self):
return self._status
def register(self):
if self._deleted:
return False
wasEventProcessed = False
aStatus = self._status
if aStatus is __class__.Status.Open:
self.setStatus(__class__.Status.Open)
wasEventProcessed = True
return wasEventProcessed
def setStatus(self, aStatus):
self._status = aStatus
def delete(self):
self._deleted = True